steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/mptrack/View_tre.cpp

4506 lines
131 KiB
C++
Raw Blame History

/*
* View_tre.cpp
* ------------
* Purpose: Tree view for managing open songs, sound files, file browser, ...
* Notes : (currently none)
* Authors: Olivier Lapicque
* OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "Mainfrm.h"
#include "InputHandler.h"
#include "ImageLists.h"
#include "View_tre.h"
#include "Mptrack.h"
#include "Moddoc.h"
#include "Dlsbank.h"
#include "dlg_misc.h"
#include "../common/mptFileIO.h"
#include "../common/FileReader.h"
#include "FileDialog.h"
#include "Globals.h"
#include "ExternalSamples.h"
#include "FolderScanner.h"
#include "LinkResolver.h"
#include "../soundlib/mod_specifications.h"
#include "../soundlib/plugins/PlugInterface.h"
#include "../soundlib/MIDIEvents.h"
#include <winioctl.h>
OPENMPT_NAMESPACE_BEGIN
CSoundFile *CModTree::m_SongFile = nullptr;
/////////////////////////////////////////////////////////////////////////////
// CModTreeDropTarget
BOOL CModTreeDropTarget::Register(CModTree *pWnd)
{
m_pModTree = pWnd;
return COleDropTarget::Register(pWnd);
}
DROPEFFECT CModTreeDropTarget::OnDragEnter(CWnd *pWnd, COleDataObject *pDataObject, DWORD dwKeyState, CPoint point)
{
if((m_pModTree) && (m_pModTree == pWnd))
return m_pModTree->OnDragEnter(pDataObject, dwKeyState, point);
return DROPEFFECT_NONE;
}
DROPEFFECT CModTreeDropTarget::OnDragOver(CWnd *pWnd, COleDataObject *pDataObject, DWORD dwKeyState, CPoint point)
{
if((m_pModTree) && (m_pModTree == pWnd))
return m_pModTree->OnDragOver(pDataObject, dwKeyState, point);
return DROPEFFECT_NONE;
}
BOOL CModTreeDropTarget::OnDrop(CWnd *pWnd, COleDataObject *pDataObject, DROPEFFECT dropEffect, CPoint point)
{
if((m_pModTree) && (m_pModTree == pWnd))
return m_pModTree->OnDrop(pDataObject, dropEffect, point);
return FALSE;
}
ModTreeDocInfo::ModTreeDocInfo(CModDoc &modDoc)
: modDoc(modDoc)
{
const CSoundFile &sndFile = modDoc.GetSoundFile();
tiPatterns.resize(sndFile.Patterns.Size(), nullptr);
tiOrders.resize(sndFile.Order.GetNumSequences());
tiSequences.resize(sndFile.Order.GetNumSequences(), nullptr);
}
/////////////////////////////////////////////////////////////////////////////
// CModTree
BEGIN_MESSAGE_MAP(CModTree, CTreeCtrl)
//{{AFX_MSG_MAP(CViewModTree)
ON_WM_MOUSEMOVE()
ON_WM_LBUTTONUP()
ON_WM_RBUTTONUP()
ON_WM_XBUTTONUP()
ON_WM_KEYDOWN()
ON_WM_DROPFILES()
ON_NOTIFY_REFLECT(NM_DBLCLK, &CModTree::OnItemDblClk)
ON_NOTIFY_REFLECT(NM_RETURN, &CModTree::OnItemReturn)
ON_NOTIFY_REFLECT(NM_RCLICK, &CModTree::OnItemRightClick)
ON_NOTIFY_REFLECT(NM_CLICK, &CModTree::OnItemLeftClick)
ON_NOTIFY_REFLECT(TVN_ITEMEXPANDED, &CModTree::OnItemExpanded)
ON_NOTIFY_REFLECT(TVN_BEGINDRAG, &CModTree::OnBeginLDrag)
ON_NOTIFY_REFLECT(TVN_BEGINRDRAG, &CModTree::OnBeginRDrag)
ON_NOTIFY_REFLECT(TVN_BEGINLABELEDIT,&CModTree::OnBeginLabelEdit)
ON_NOTIFY_REFLECT(TVN_ENDLABELEDIT, &CModTree::OnEndLabelEdit)
ON_COMMAND(ID_MODTREE_REFRESH, &CModTree::OnRefreshTree)
ON_COMMAND(ID_MODTREE_EXECUTE, &CModTree::OnExecuteItem)
ON_COMMAND(ID_MODTREE_REMOVE, &CModTree::OnDeleteTreeItem)
ON_COMMAND(ID_MODTREE_PLAY, &CModTree::OnPlayTreeItem)
ON_COMMAND(ID_MODTREE_REFRESHINSTRLIB, &CModTree::OnRefreshInstrLib)
ON_COMMAND(ID_MODTREE_OPENITEM, &CModTree::OnOpenTreeItem)
ON_COMMAND(ID_MODTREE_MUTE, &CModTree::OnMuteTreeItem)
ON_COMMAND(ID_MODTREE_MUTE_ONLY_EFFECTS, &CModTree::OnMuteOnlyEffects)
ON_COMMAND(ID_MODTREE_SOLO, &CModTree::OnSoloTreeItem)
ON_COMMAND(ID_MODTREE_UNMUTEALL, &CModTree::OnUnmuteAllTreeItem)
ON_COMMAND(ID_MODTREE_DUPLICATE, &CModTree::OnDuplicateTreeItem)
ON_COMMAND(ID_MODTREE_INSERT, &CModTree::OnInsertTreeItem)
ON_COMMAND(ID_MODTREE_SWITCHTO, &CModTree::OnSwitchToTreeItem)
ON_COMMAND(ID_MODTREE_CLOSE, &CModTree::OnCloseItem)
ON_COMMAND(ID_MODTREE_SETPATH, &CModTree::OnSetItemPath)
ON_COMMAND(ID_MODTREE_SAVEITEM, &CModTree::OnSaveItem)
ON_COMMAND(ID_MODTREE_SAVEALL, &CModTree::OnSaveAll)
ON_COMMAND(ID_MODTREE_RELOADITEM, &CModTree::OnReloadItem)
ON_COMMAND(ID_MODTREE_RELOADALL, &CModTree::OnReloadAll)
ON_COMMAND(ID_MODTREE_FINDMISSING, &CModTree::OnFindMissing)
ON_COMMAND(ID_MODTREE_RENAME, &CModTree::OnRenameItem)
ON_COMMAND(ID_ADD_SOUNDBANK, &CModTree::OnAddDlsBank)
ON_COMMAND(ID_IMPORT_MIDILIB, &CModTree::OnImportMidiLib)
ON_COMMAND(ID_EXPORT_MIDILIB, &CModTree::OnExportMidiLib)
ON_COMMAND(ID_SOUNDBANK_PROPERTIES, &CModTree::OnSoundBankProperties)
ON_COMMAND(ID_MODTREE_SHOWDIRS, &CModTree::OnShowDirectories)
ON_COMMAND(ID_MODTREE_SHOWALLFILES, &CModTree::OnShowAllFiles)
ON_COMMAND(ID_MODTREE_SOUNDFILESONLY,&CModTree::OnShowSoundFiles)
ON_COMMAND(ID_MODTREE_GOTO_INSDIR, &CModTree::OnGotoInstrumentDir)
ON_COMMAND(ID_MODTREE_GOTO_SMPDIR, &CModTree::OnGotoSampleDir)
ON_MESSAGE(WM_MOD_KEYCOMMAND, &CModTree::OnCustomKeyMsg) //rewbs.customKeys
ON_MESSAGE(WM_MOD_MIDIMSG, &CModTree::OnMidiMsg)
//}}AFX_MSG_MAP
ON_WM_KILLFOCUS()
ON_WM_SETFOCUS()
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CViewModTree construction/destruction
CModTree::CModTree(CModTree *pDataTree)
: m_pDataTree(pDataTree)
{
if(m_pDataTree != nullptr)
{
// Set up instrument library monitoring thread
m_hWatchDirKillThread = CreateEvent(nullptr, FALSE, FALSE, nullptr);
m_hSwitchWatchDir = CreateEvent(nullptr, FALSE, FALSE, nullptr);
m_WatchDirThread = std::thread([this]() { MonitorInstrumentLibrary(); });
}
MemsetZero(m_tiMidi);
MemsetZero(m_tiPerc);
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN7)
// Wine does not support natural sorting with SORT_DIGITSASNUMBERS, fall back to normal sorting
if(!::CompareString(LOCALE_USER_DEFAULT, m_stringCompareFlags, _T(""), -1, _T(""), -1))
m_stringCompareFlags &= ~SORT_DIGITSASNUMBERS;
#endif
}
CModTree::~CModTree()
{
delete m_SongFile;
m_SongFile = nullptr;
if(m_pDataTree != nullptr)
{
SetEvent(m_hWatchDirKillThread);
m_WatchDirThread.join();
CloseHandle(m_hSwitchWatchDir);
CloseHandle(m_hWatchDirKillThread);
}
}
void CModTree::Init()
{
m_modExtensions = CSoundFile::GetSupportedExtensions(false);
m_MediaFoundationExtensions = FileType(CSoundFile::GetMediaFoundationFileTypes()).GetExtensions();
DWORD dwRemove = TVS_SINGLEEXPAND;
DWORD dwAdd = TVS_EDITLABELS | TVS_HASLINES | TVS_LINESATROOT | TVS_HASBUTTONS | TVS_SHOWSELALWAYS;
if(IsSampleBrowser())
{
dwRemove |= (TVS_HASLINES | TVS_LINESATROOT | TVS_HASBUTTONS | TVS_SHOWSELALWAYS);
dwAdd &= ~(TVS_HASLINES | TVS_LINESATROOT | TVS_HASBUTTONS | TVS_SHOWSELALWAYS);
}
if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_SINGLEEXPAND)
{
dwRemove &= ~TVS_SINGLEEXPAND;
dwAdd |= TVS_SINGLEEXPAND;
m_dwStatus |= TREESTATUS_SINGLEEXPAND;
}
ModifyStyle(dwRemove, dwAdd);
ModifyStyleEx(0, WS_EX_ACCEPTFILES);
if(!IsSampleBrowser())
{
std::vector<TCHAR> curDir(::GetCurrentDirectory(0, nullptr), '\0');
::GetCurrentDirectory(static_cast<DWORD>(curDir.size()), curDir.data());
mpt::PathString dirs[] =
{
TrackerSettings::Instance().PathSamples.GetDefaultDir(),
TrackerSettings::Instance().PathInstruments.GetDefaultDir(),
TrackerSettings::Instance().PathSongs.GetDefaultDir(),
mpt::PathString::FromNative(curDir.data())
};
for(auto &path : dirs)
{
m_InstrLibPath = std::move(path);
if(!m_InstrLibPath.empty())
break;
}
m_InstrLibPath.EnsureTrailingSlash();
m_pDataTree->InsLibSetFullPath(m_InstrLibPath, mpt::PathString());
}
SetImageList(&CMainFrame::GetMainFrame()->m_MiscIcons, TVSIL_NORMAL);
if(!IsSampleBrowser())
{
// Create Midi Library
m_hMidiLib = InsertItem(_T("MIDI Library"), IMAGE_FOLDER, IMAGE_FOLDER, TVI_ROOT, TVI_LAST);
for(UINT iMidGrp = 0; iMidGrp < 17; iMidGrp++)
{
InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM, mpt::ToCString(mpt::Charset::ASCII, szMidiGroupNames[iMidGrp]), IMAGE_FOLDER, IMAGE_FOLDER, 0, 0, (MODITEM_HDR_MIDIGROUP << MIDILIB_SHIFT) | iMidGrp, m_hMidiLib, TVI_LAST);
}
}
m_hInsLib = InsertItem(_T("Instrument Library"), IMAGE_FOLDER, IMAGE_FOLDER, TVI_ROOT, TVI_LAST);
SetItemData(m_hInsLib, reinterpret_cast<DWORD_PTR>(m_hInsLib));
RefreshMidiLibrary();
RefreshDlsBanks();
RefreshInstrumentLibrary();
m_DropTarget.Register(this);
}
BOOL CModTree::PreTranslateMessage(MSG *pMsg)
{
if(!pMsg)
return TRUE;
if(m_doLabelEdit)
{
if(pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_RETURN)
{
// End editing by making edit box lose focus.
SetFocus();
return TRUE;
}
return CTreeCtrl::PreTranslateMessage(pMsg);
}
if(pMsg->message == WM_KEYDOWN)
{
switch(pMsg->wParam)
{
case VK_SPACE:
if(!(pMsg->lParam & 0x40000000))
OnPlayTreeItem();
return TRUE;
case VK_RETURN:
if(!(pMsg->lParam & 0x40000000))
{
HTREEITEM hItem = GetSelectedItem();
if(hItem)
{
if(CMainFrame::GetInputHandler()->CtrlPressed())
{
const ModItem modItem = GetModItem(hItem);
static constexpr ModItemType instrumentTypes[] = {MODITEM_INSLIB_SAMPLE, MODITEM_INSLIB_INSTRUMENT, MODITEM_MIDIINSTRUMENT, MODITEM_MIDIPERCUSSION, MODITEM_DLSBANK_INSTRUMENT};
if(mpt::contains(instrumentTypes, modItem.type))
{
// Ctrl+Enter: Load sample into currently selected sample or instrument slot
// Additionally pressing Shift creates a new sample or instrument slot. Shift key is handled in the Drag&drop handler
CModScrollView *view = static_cast<CModScrollView *>(CMainFrame::GetMainFrame()->GetActiveView());
if(view)
{
const char *className = view->GetRuntimeClass()->m_lpszClassName;
const bool isSampleView = !strcmp("CViewSample", className);
const bool isInstrumentView = !strcmp("CViewInstrument", className);
mpt::PathString fullPath = InsLibGetFullPath(hItem);
DRAGONDROP dropInfo;
m_hItemDrag = hItem;
m_itemDrag = modItem;
if((isSampleView || isInstrumentView) && GetDropInfo(dropInfo, fullPath))
{
view->SendMessage(WM_MOD_DRAGONDROPPING, TRUE, reinterpret_cast<LPARAM>(&dropInfo));
// In case a message box like "create instrument for sample?" showed up
SetFocus();
}
}
} else if(!IsSampleBrowser())
{
// Ctrl+Enter: Edit item
EditLabel(hItem);
}
} else
{
if(!ExecuteItem(hItem))
{
if(ItemHasChildren(hItem))
{
Expand(hItem, TVE_TOGGLE);
}
}
}
}
}
return TRUE;
case VK_TAB:
// Tab: Switch between folder and file view.
if(this == CMainFrame::GetMainFrame()->GetUpperTreeview())
CMainFrame::GetMainFrame()->GetLowerTreeview()->SetFocus();
else
CMainFrame::GetMainFrame()->GetUpperTreeview()->SetFocus();
return TRUE;
case VK_BACK:
// Backspace: Go up one directory
if(GetParentRootItem(GetSelectedItem()) == m_hInsLib || IsSampleBrowser())
{
InstrumentLibraryChDir(P_(".."), !m_SongFileName.empty());
return TRUE;
}
break;
case VK_INSERT:
InsertOrDupItem(!CMainFrame::GetInputHandler()->ShiftPressed());
return TRUE;
case VK_APPS:
// Handle Application (menu) key
if(HTREEITEM item = GetSelectedItem())
{
CRect rect;
GetItemRect(item, &rect, FALSE);
ClientToScreen(rect);
OnItemRightClick(item, rect.TopLeft());
}
return TRUE;
}
} else if(pMsg->message == WM_CHAR)
{
ModItem item = GetModItem(GetSelectedItem());
switch(item.type)
{
case MODITEM_SAMPLE:
case MODITEM_INSTRUMENT:
case MODITEM_MIDIINSTRUMENT:
case MODITEM_MIDIPERCUSSION:
case MODITEM_INSLIB_SAMPLE:
case MODITEM_INSLIB_INSTRUMENT:
case MODITEM_DLSBANK_INSTRUMENT:
// Avoid cycling through tree-view elements on key hold
return true;
}
}
//We handle keypresses before Windows has a chance to handle them (for alt etc..)
if ((pMsg->message == WM_SYSKEYUP) || (pMsg->message == WM_KEYUP) ||
(pMsg->message == WM_SYSKEYDOWN) || (pMsg->message == WM_KEYDOWN))
{
CInputHandler *ih = CMainFrame::GetInputHandler();
//Translate message manually
UINT nChar = (UINT)pMsg->wParam;
UINT nRepCnt = LOWORD(pMsg->lParam);
UINT nFlags = HIWORD(pMsg->lParam);
KeyEventType kT = ih->GetKeyEventType(nFlags);
InputTargetContext ctx = (InputTargetContext)(kCtxViewTree);
if(ih->KeyEvent(ctx, nChar, nRepCnt, nFlags, kT) != kcNull)
return true; // Mapped to a command, no need to pass message on.
}
return CTreeCtrl::PreTranslateMessage(pMsg);
}
mpt::PathString CModTree::InsLibGetFullPath(HTREEITEM hItem) const
{
mpt::PathString fullPath = m_InstrLibPath;
fullPath.EnsureTrailingSlash();
return fullPath + mpt::PathString::FromCString(GetItemText(hItem));
}
bool CModTree::InsLibSetFullPath(const mpt::PathString &libPath, const mpt::PathString &songName)
{
if(!songName.empty() && mpt::PathString::CompareNoCase(m_SongFileName, songName))
{
// Load module for previewing its instruments
InputFile f(libPath + songName, TrackerSettings::Instance().MiscCacheCompleteFileBeforeLoading);
if(f.IsValid())
{
FileReader file = GetFileReader(f);
if(file.IsValid())
{
if(m_SongFile != nullptr)
{
m_SongFile->Destroy();
} else
{
m_SongFile = new(std::nothrow) CSoundFile;
}
if(m_SongFile != nullptr)
{
try
{
if(!m_SongFile->Create(file, CSoundFile::loadNoPatternOrPluginData, nullptr))
{
return false;
}
} catch(mpt::out_of_memory e)
{
mpt::delete_out_of_memory(e);
return false;
} catch(const std::exception &)
{
return false;
}
// Destroy some stuff that we're not going to use anyway.
m_SongFile->Patterns.DestroyPatterns();
m_SongFile->m_songMessage.clear();
}
}
} else
{
return false;
}
}
m_InstrLibPath = libPath;
m_SongFileName = songName;
return true;
}
bool CModTree::SetSoundFile(FileReader &file)
{
std::unique_ptr<CSoundFile> sndFile;
try
{
sndFile = std::make_unique<CSoundFile>();
if(!sndFile->Create(file, CSoundFile::loadNoPatternOrPluginData))
{
return false;
}
} catch(mpt::out_of_memory e)
{
mpt::delete_out_of_memory(e);
return false;
} catch(const std::exception &)
{
return false;
}
if(m_SongFile != nullptr)
{
m_SongFile->Destroy();
delete m_SongFile;
}
m_SongFile = sndFile.release();
m_SongFile->Patterns.DestroyPatterns();
m_SongFile->m_songMessage.clear();
const mpt::PathString fileName = file.GetOptionalFileName().value_or(P_(""));
m_InstrLibPath = fileName.GetPath();
m_SongFileName = fileName.GetFullFileName();
RefreshInstrumentLibrary();
return true;
}
void CModTree::OnOptionsChanged()
{
DWORD dwRemove = TVS_SINGLEEXPAND, dwAdd = 0;
m_dwStatus &= ~TREESTATUS_SINGLEEXPAND;
if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_SINGLEEXPAND)
{
dwRemove = 0;
dwAdd = TVS_SINGLEEXPAND;
m_dwStatus |= TREESTATUS_SINGLEEXPAND;
}
ModifyStyle(dwRemove, dwAdd);
}
void CModTree::AddDocument(CModDoc &modDoc)
{
const auto [it, inserted] = m_docInfo.try_emplace(&modDoc, modDoc);
if(!inserted)
return;
auto &info = it->second;
UpdateView(info, UpdateHint().ModType());
if(info.hSong)
{
Expand(info.hSong, TVE_EXPAND);
EnsureVisible(info.hSong);
SelectItem(info.hSong);
}
}
void CModTree::RemoveDocument(const CModDoc &modDoc)
{
auto doc = m_docInfo.find(&modDoc);
if(doc == m_docInfo.end())
return;
DeleteItem(doc->second.hSong);
m_docInfo.erase(doc);
}
// Get CModDoc that is associated with a tree item
ModTreeDocInfo *CModTree::GetDocumentInfoFromItem(HTREEITEM hItem)
{
hItem = GetParentRootItem(hItem);
if(hItem != nullptr)
{
// Root item has moddoc pointer
const auto doc = m_docInfo.find(reinterpret_cast<const CModDoc *>(GetItemData(hItem)));
if(doc != m_docInfo.end() && hItem == doc->second.hSong)
{
return &doc->second;
}
}
return nullptr;
}
// Get modtree doc information for a given CModDoc
ModTreeDocInfo *CModTree::GetDocumentInfoFromModDoc(CModDoc &modDoc)
{
auto doc = m_docInfo.find(&modDoc);
if(doc != m_docInfo.end())
return &doc->second;
else
return nullptr;
}
size_t CModTree::GetDLSBankIndexFromItem(HTREEITEM hItem) const
{
return static_cast<size_t>(std::distance(m_tiDLS.begin(), std::find(m_tiDLS.begin(), m_tiDLS.end(), GetParentRootItem(hItem))));
}
CDLSBank *CModTree::GetDLSBankFromItem(HTREEITEM hItem) const
{
const auto bank = GetDLSBankIndexFromItem(hItem);
if(bank < CTrackApp::gpDLSBanks.size())
return CTrackApp::gpDLSBanks[bank].get();
else
return nullptr;
}
/////////////////////////////////////////////////////////////////////////////
// CViewModTree drawing
void CModTree::RefreshMidiLibrary()
{
CString s;
CString stmp;
TVITEM tvi;
const MidiLibrary &midiLib = CTrackApp::GetMidiLibrary();
if(IsSampleBrowser())
return;
// Midi Programs
HTREEITEM parent = GetChildItem(m_hMidiLib);
for(UINT iMidi = 0; iMidi < 128; iMidi++)
{
DWORD dwImage = IMAGE_INSTRMUTE;
s = mpt::cfmt::val(iMidi) + _T(": ") + mpt::ToCString(mpt::Charset::ASCII, szMidiProgramNames[iMidi]);
const LPARAM param = (MODITEM_MIDIINSTRUMENT << MIDILIB_SHIFT) | iMidi;
if(!midiLib[iMidi].empty())
{
s += _T(": ") + midiLib[iMidi].GetFullFileName().ToCString();
dwImage = IMAGE_INSTRUMENTS;
}
if(!m_tiMidi[iMidi])
{
m_tiMidi[iMidi] = InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
s, dwImage, dwImage, 0, 0, param, parent, TVI_LAST);
} else
{
tvi.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
tvi.hItem = m_tiMidi[iMidi];
tvi.pszText = stmp.GetBuffer(s.GetLength() + 1);
tvi.cchTextMax = stmp.GetAllocLength();
tvi.iImage = tvi.iSelectedImage = dwImage;
GetItem(&tvi);
s.ReleaseBuffer();
if(s != stmp || tvi.iImage != (int)dwImage)
{
SetItem(m_tiMidi[iMidi], TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
s, dwImage, dwImage, 0, 0, param);
}
}
if((iMidi % 8u) == 7u)
{
parent = GetNextSiblingItem(parent);
}
}
// Midi Percussions
for(UINT iPerc = 24; iPerc <= 84; iPerc++)
{
DWORD dwImage = IMAGE_NOSAMPLE;
s = mpt::ToCString(CSoundFile::GetNoteName((ModCommand::NOTE)(iPerc + NOTE_MIN), CSoundFile::GetDefaultNoteNames()))
+ _T(": ") + mpt::ToCString(mpt::Charset::ASCII, szMidiPercussionNames[iPerc - 24]);
const LPARAM param = (MODITEM_MIDIPERCUSSION << MIDILIB_SHIFT) | iPerc;
if(!midiLib[iPerc | 0x80].empty())
{
s += _T(": ") + midiLib[iPerc | 0x80].GetFullFileName().ToCString();
dwImage = IMAGE_SAMPLES;
}
if(!m_tiPerc[iPerc])
{
m_tiPerc[iPerc] = InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
s, dwImage, dwImage, 0, 0, param, parent, TVI_LAST);
} else
{
tvi.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
tvi.hItem = m_tiPerc[iPerc];
tvi.pszText = stmp.GetBuffer(s.GetLength() + 1);
tvi.cchTextMax = stmp.GetAllocLength();
tvi.iImage = tvi.iSelectedImage = dwImage;
GetItem(&tvi);
s.ReleaseBuffer();
if(s != stmp || tvi.iImage != (int)dwImage)
{
SetItem(m_tiPerc[iPerc], TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
s, dwImage, dwImage, 0, 0, param);
}
}
}
}
void CModTree::RefreshDlsBanks()
{
const mpt::Charset charset = mpt::Charset::Locale;
TCHAR s[256];
HTREEITEM hDlsRoot = m_hMidiLib;
if(IsSampleBrowser())
return;
if(m_tiDLS.size() < CTrackApp::gpDLSBanks.size())
{
m_tiDLS.resize(CTrackApp::gpDLSBanks.size(), nullptr);
}
for(size_t iDls = 0; iDls < CTrackApp::gpDLSBanks.size(); iDls++)
{
if(CTrackApp::gpDLSBanks[iDls])
{
if(!m_tiDLS[iDls])
{
TVSORTCB tvs;
CDLSBank dlsBank = *CTrackApp::gpDLSBanks[iDls];
// Add DLS file folder
m_tiDLS[iDls] = InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
dlsBank.GetFileName().GetFullFileName().AsNative().c_str(), IMAGE_FOLDER, IMAGE_FOLDER, 0, 0, iDls, TVI_ROOT, hDlsRoot);
// Memorize Banks
std::map<uint16, HTREEITEM> banks;
// Add Drum Kits folder
HTREEITEM hDrums = InsertItem(TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE | TVIF_PARAM,
_T("Drum Kits"), IMAGE_FOLDER, IMAGE_FOLDER, 0, 0, DLS_DRUM_FOLDER_LPARAM, m_tiDLS[iDls], TVI_LAST);
// Add Instruments
UINT nInstr = dlsBank.GetNumInstruments();
MPT_ASSERT(nInstr <= 0x10000);
for(UINT iIns = 0; iIns < nInstr; iIns++)
{
const DLSINSTRUMENT *pDlsIns = dlsBank.GetInstrument(iIns);
if(pDlsIns)
{
TCHAR szName[256];
wsprintf(szName, _T("%u: %s"), pDlsIns->ulInstrument & 0x7F, mpt::ToCString(charset, pDlsIns->szName).GetString());
const LPARAM lParamInstr = DlsItem::ToLPARAM(static_cast<uint16>(iIns), (pDlsIns->ulInstrument & 0x7F), false);
// Drum Kit
if(pDlsIns->ulBank & F_INSTRUMENT_DRUMS)
{
HTREEITEM hKit = InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
szName, IMAGE_FOLDER, IMAGE_FOLDER, 0, 0, lParamInstr, hDrums, TVI_LAST);
MPT_ASSERT(pDlsIns->Regions.size() <= 0x8000);
for(uint32 iRgn = 0; iRgn < static_cast<uint32>(pDlsIns->Regions.size()); iRgn++)
{
if(pDlsIns->Regions[iRgn].IsDummy())
continue;
UINT keymin = pDlsIns->Regions[iRgn].uKeyMin;
UINT keymax = pDlsIns->Regions[iRgn].uKeyMax;
const char *regionName = dlsBank.GetRegionName(iIns, iRgn);
if(regionName == nullptr || !regionName[0])
{
if(keymin >= 24 && keymin <= 84)
regionName = szMidiPercussionNames[keymin - 24];
else
regionName = "";
}
if(keymin >= keymax)
{
wsprintf(szName, _T("%s%u: %s"),
mpt::ToCString(CSoundFile::GetDefaultNoteName(keymin % 12)).GetString(),
keymin / 12,
mpt::ToCString(charset, regionName).GetString());
} else
{
wsprintf(szName, _T("%s%u-%s%u: %s"),
mpt::ToCString(CSoundFile::GetDefaultNoteName(keymin % 12)).GetString(),
keymin / 12,
mpt::ToCString(CSoundFile::GetDefaultNoteName(keymax % 12)).GetString(),
keymax / 12,
mpt::ToCString(charset, regionName).GetString());
}
LPARAM lParam = DlsItem::ToLPARAM(static_cast<uint16>(iIns), static_cast<uint16>(iRgn), true);
InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
szName, IMAGE_INSTRUMENTS, IMAGE_INSTRUMENTS, 0, 0, lParam, hKit, TVI_LAST);
}
tvs.hParent = hKit;
tvs.lpfnCompare = ModTreeDrumCompareProc;
tvs.lParam = reinterpret_cast<LPARAM>(CTrackApp::gpDLSBanks[iDls].get());
SortChildrenCB(&tvs);
} else
// Melodic
{
uint16 mbank = (pDlsIns->ulBank & 0x7F7F);
auto hbank = banks.find(mbank);
if(hbank == banks.end())
{
wsprintf(s, (mbank) ? _T("Melodic Bank %02d.%02d") : _T("Melodic"), mbank >> 8, mbank & 0x7F);
// Find out where to insert this bank in the tree
hbank = banks.insert(std::make_pair(mbank, nullptr)).first;
HTREEITEM insertAfter = (hbank == banks.begin()) ? TVI_FIRST : std::prev(hbank)->second;
hbank->second = InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
s, IMAGE_FOLDER, IMAGE_FOLDER, 0, 0, 0,
m_tiDLS[iDls], insertAfter);
}
InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
szName, IMAGE_INSTRUMENTS, IMAGE_INSTRUMENTS, 0, 0, lParamInstr, hbank->second, TVI_LAST);
}
}
}
// Sort items
for(auto &b : banks)
{
tvs.hParent = b.second;
tvs.lpfnCompare = ModTreeInsLibCompareProc;
tvs.lParam = reinterpret_cast<LPARAM>(this);
SortChildrenCB(&tvs);
}
if(hDrums)
{
tvs.hParent = hDrums;
tvs.lpfnCompare = ModTreeInsLibCompareProc;
tvs.lParam = reinterpret_cast<LPARAM>(this);
SortChildrenCB(&tvs);
}
}
hDlsRoot = m_tiDLS[iDls];
} else
{
if(m_tiDLS[iDls])
{
DeleteItem(m_tiDLS[iDls]);
m_tiDLS[iDls] = nullptr;
}
}
}
}
void CModTree::RefreshInstrumentLibrary()
{
SetRedraw(FALSE);
// Check if the currently selected item should be selected after refreshing
CString selectedName;
if((IsSampleBrowser() || GetParentRootItem(GetSelectedItem()) == m_hInsLib)
&& GetItemText(GetSampleBrowser()->m_hInsLib) == (m_SongFileName.empty() ? m_InstrLibPath : m_SongFileName).ToCString())
{
selectedName = GetItemText(GetSelectedItem());
}
if(!m_InstrLibHighlightPath.empty())
{
selectedName = m_InstrLibHighlightPath.ToCString();
}
m_InstrLibHighlightPath = {};
EmptyInstrumentLibrary();
FillInstrumentLibrary(selectedName);
auto selectedItem = GetSelectedItem();
if(selectedItem)
EnsureVisible(selectedItem);
SetRedraw(TRUE);
if(!IsSampleBrowser())
{
m_pDataTree->InsLibSetFullPath(m_InstrLibPath, m_SongFileName);
m_pDataTree->RefreshInstrumentLibrary();
}
}
void CModTree::UpdateView(ModTreeDocInfo &info, UpdateHint hint)
{
TCHAR stmp[256];
TVITEM tvi;
MemsetZero(tvi);
const FlagSet<HintType> hintType = hint.GetType();
if(IsSampleBrowser() || hintType == HINT_NONE)
return;
const CModDoc &modDoc = info.modDoc;
const CSoundFile &sndFile = modDoc.GetSoundFile();
// Create headers
const GeneralHint generalHint = hint.ToType<GeneralHint>();
if(generalHint.GetType()[HINT_MODTYPE | HINT_MODGENERAL] || (!info.hSong))
{
// Module folder + sub folders
CString name = modDoc.GetPathNameMpt().GetFullFileName().ToCString();
if(name.IsEmpty())
name = mpt::PathString::FromCString(modDoc.GetTitle()).SanitizeComponent().ToCString();
if(!info.hSong)
{
info.hSong = InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM, name, IMAGE_FOLDER, IMAGE_FOLDER, 0, 0, reinterpret_cast<LPARAM>(&info.modDoc), TVI_ROOT, TVI_FIRST);
info.hOrders = InsertItem(_T("Sequence"), IMAGE_FOLDER, IMAGE_FOLDER, info.hSong, TVI_LAST);
info.hPatterns = InsertItem(_T("Patterns"), IMAGE_FOLDER, IMAGE_FOLDER, info.hSong, TVI_LAST);
info.hSamples = InsertItem(_T("Samples"), IMAGE_FOLDER, IMAGE_FOLDER, info.hSong, TVI_LAST);
} else if(generalHint.GetType()[HINT_MODGENERAL | HINT_MODTYPE])
{
if(name != GetItemText(info.hSong))
{
SetItemText(info.hSong, name);
}
}
}
if(sndFile.GetModSpecifications().instrumentsMax > 0)
{
if(!info.hInstruments)
info.hInstruments = InsertItem(_T("Instruments"), IMAGE_FOLDER, IMAGE_FOLDER, info.hSong, info.hSamples);
} else
{
if(info.hInstruments)
{
DeleteItem(info.hInstruments);
info.hInstruments = NULL;
}
}
if(!info.hComments)
info.hComments = InsertItem(_T("Comments"), IMAGE_COMMENTS, IMAGE_COMMENTS, info.hSong, TVI_LAST);
// Add effects
const PluginHint pluginHint = hint.ToType<PluginHint>();
if(pluginHint.GetType()[HINT_MODTYPE | HINT_PLUGINNAMES])
{
HTREEITEM hItem = info.hEffects ? GetChildItem(info.hEffects) : nullptr;
PLUGINDEX firstPlug = 0, lastPlug = MAX_MIXPLUGINS - 1;
if(pluginHint.GetPlugin() && hItem)
{
// Only update one specific plugin name
firstPlug = lastPlug = pluginHint.GetPlugin() - 1;
while(hItem && GetItemData(hItem) != firstPlug)
{
hItem = GetNextSiblingItem(hItem);
}
}
bool hasPlugs = false;
for(PLUGINDEX i = firstPlug; i <= lastPlug; i++)
{
const SNDMIXPLUGIN &plugin = sndFile.m_MixPlugins[i];
if(plugin.IsValidPlugin())
{
// Now we can be sure that we want to create this folder.
if(!info.hEffects)
{
info.hEffects = InsertItem(_T("Plugins"), IMAGE_FOLDER, IMAGE_FOLDER, info.hSong, info.hInstruments ? info.hInstruments : info.hSamples);
}
CString s = MPT_CFORMAT("FX{}: {}")(i + 1, mpt::ToCString(plugin.GetName()));
int nImage = IMAGE_NOPLUGIN;
if(plugin.pMixPlugin != nullptr)
nImage = (plugin.pMixPlugin->IsInstrument()) ? IMAGE_PLUGININSTRUMENT : IMAGE_EFFECTPLUGIN;
if(hItem)
{
// Replace existing item
tvi.mask = TVIF_TEXT | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
tvi.hItem = hItem;
tvi.pszText = stmp;
tvi.cchTextMax = mpt::saturate_cast<int>(std::size(stmp));
GetItem(&tvi);
if(tvi.iImage != nImage || tvi.lParam != i || s != CString(tvi.pszText))
{
SetItem(hItem, TVIF_TEXT | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM, s, nImage, nImage, 0, 0, i);
}
hItem = GetNextSiblingItem(hItem);
} else
{
InsertItem(TVIF_TEXT | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM, s, nImage, nImage, 0, 0, i, info.hEffects, TVI_LAST);
}
hasPlugs = true;
}
}
if(!hasPlugs && firstPlug == lastPlug)
{
// If we only updated one plugin, we still need to check all the other slots if there is any plugin in them.
for(const auto &plug : sndFile.m_MixPlugins)
{
if(plug.IsValidPlugin())
{
hasPlugs = true;
break;
}
}
}
if(!hasPlugs && info.hEffects)
{
DeleteItem(info.hEffects);
info.hEffects = nullptr;
} else if(!pluginHint.GetPlugin())
{
// Delete superfluous tree items
while(hItem)
{
HTREEITEM nextItem = GetNextSiblingItem(hItem);
DeleteItem(hItem);
hItem = nextItem;
}
}
}
// Add Orders
const PatternHint patternHint = hint.ToType<PatternHint>();
const SequenceHint seqHint = hint.ToType<SequenceHint>();
if(info.hOrders && (seqHint.GetType()[HINT_MODTYPE | HINT_MODSEQUENCE | HINT_SEQNAMES] || patternHint.GetType()[HINT_PATNAMES]))
{
const PATTERNINDEX nPat = patternHint.GetPattern();
bool adjustParentNode = false; // adjust sequence name of "Sequence" node?
// (only one seq remaining || previously only one sequence): update parent item
if((info.tiSequences.size() > 1 && sndFile.Order.GetNumSequences() == 1) || (info.tiSequences.size() == 1 && sndFile.Order.GetNumSequences() > 1))
{
for(auto &seq : info.tiOrders)
{
for(auto &ord : seq)
{
if(ord)
DeleteItem(ord);
ord = nullptr;
}
}
for(auto &seq : info.tiSequences)
{
if(seq)
DeleteItem(seq);
seq = nullptr;
}
info.tiOrders.resize(sndFile.Order.GetNumSequences());
info.tiSequences.resize(sndFile.Order.GetNumSequences(), nullptr);
adjustParentNode = true;
}
// If there are too many sequences, delete them.
for(size_t seq = sndFile.Order.GetNumSequences(); seq < info.tiSequences.size(); seq++) if (info.tiSequences[seq])
{
for(auto &ord : info.tiOrders[seq]) if (ord)
{
DeleteItem(ord); ord = nullptr;
}
DeleteItem(info.tiSequences[seq]); info.tiSequences[seq] = nullptr;
}
if (info.tiSequences.size() < sndFile.Order.GetNumSequences()) // Resize tiSequences if needed.
{
info.tiSequences.resize(sndFile.Order.GetNumSequences(), nullptr);
info.tiOrders.resize(sndFile.Order.GetNumSequences());
}
HTREEITEM hAncestorNode = info.hOrders;
SEQUENCEINDEX nSeqMin = 0, nSeqMax = sndFile.Order.GetNumSequences() - 1;
SEQUENCEINDEX nHintParam = seqHint.GetSequence();
if(seqHint.GetType()[HINT_SEQNAMES] && (nHintParam <= nSeqMax))
nSeqMin = nSeqMax = nHintParam;
// Adjust caption of the "Sequence" node (if only one sequence exists, it should be labeled with the sequence name)
if((seqHint.GetType()[HINT_SEQNAMES] && sndFile.Order.GetNumSequences() == 1) || adjustParentNode)
{
CString seqName = mpt::ToCString(sndFile.Order(0).GetName());
if(seqName.IsEmpty() || sndFile.Order.GetNumSequences() > 1)
seqName = _T("Sequence");
else
seqName = _T("Sequence: ") + seqName;
SetItem(info.hOrders, TVIF_TEXT, seqName, 0, 0, 0, 0, 0);
}
// go through all sequences
CString seqName;
for(SEQUENCEINDEX seq = nSeqMin; seq <= nSeqMax; seq++)
{
if(sndFile.Order.GetNumSequences() > 1)
{
// more than one sequence -> add folder
if(sndFile.Order(seq).GetName().empty())
{
seqName = MPT_CFORMAT("Sequence {}")(seq + 1);
} else
{
seqName = MPT_CFORMAT("{}: ")(seq + 1);
seqName += mpt::ToCString(sndFile.Order(seq).GetName());
}
UINT state = (seq == sndFile.Order.GetCurrentSequenceIndex()) ? TVIS_BOLD : 0;
if(info.tiSequences[seq] == NULL)
{
info.tiSequences[seq] = InsertItem(seqName, IMAGE_FOLDER, IMAGE_FOLDER, info.hOrders, TVI_LAST);
}
// Update bold item
_tcscpy(stmp, seqName);
tvi.mask = TVIF_TEXT | TVIF_HANDLE | TVIF_STATE | TVIF_PARAM;
tvi.state = 0;
tvi.stateMask = TVIS_BOLD;
tvi.hItem = info.tiSequences[seq];
tvi.pszText = stmp;
tvi.cchTextMax = mpt::saturate_cast<int>(std::size(stmp));
LPARAM param = (seq << SEQU_SHIFT) | ORDERINDEX_INVALID;
GetItem(&tvi);
if(tvi.state != state || tvi.pszText != seqName || tvi.lParam != param)
SetItem(info.tiSequences[seq], TVIF_TEXT | TVIF_STATE | TVIF_PARAM, seqName, 0, 0, state, TVIS_BOLD, param);
hAncestorNode = info.tiSequences[seq];
}
const ORDERINDEX ordLength = sndFile.Order(seq).GetLengthTailTrimmed();
// If there are items past the new sequence length, delete them.
for(size_t nOrd = ordLength; nOrd < info.tiOrders[seq].size(); nOrd++) if (info.tiOrders[seq][nOrd])
{
DeleteItem(info.tiOrders[seq][nOrd]); info.tiOrders[seq][nOrd] = NULL;
}
if (info.tiOrders[seq].size() < ordLength) // Resize tiOrders if needed.
info.tiOrders[seq].resize(ordLength, nullptr);
const bool patNamesOnly = patternHint.GetType()[HINT_PATNAMES];
//if (hintFlagPart == HINT_PATNAMES) && (dwHintParam < sndFile.Order().GetLength())) imin = imax = dwHintParam;
CString patName;
for(ORDERINDEX iOrd = 0; iOrd < ordLength; iOrd++)
{
TCHAR s[256];
s[0] = 0;
if(patNamesOnly && sndFile.Order(seq)[iOrd] != nPat)
continue;
UINT state = (iOrd == info.ordSel && seq == info.seqSel) ? TVIS_BOLD : 0;
if(sndFile.Order(seq)[iOrd] < sndFile.Patterns.Size())
{
patName = mpt::ToCString(sndFile.GetCharsetInternal(), sndFile.Patterns[sndFile.Order(seq)[iOrd]].GetName());
if(!patName.IsEmpty())
{
wsprintf(s, (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_HEXDISPLAY) ? _T("[%02Xh] %u: ") : _T("[%02u] %u: "),
iOrd, sndFile.Order(seq)[iOrd]);
_tcscat(s, patName.GetString());
} else
{
wsprintf(s, (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_HEXDISPLAY) ? _T("[%02Xh] Pattern %u") : _T("[%02u] Pattern %u"),
iOrd, sndFile.Order(seq)[iOrd]);
}
} else
{
if(sndFile.Order(seq)[iOrd] == sndFile.Order.GetIgnoreIndex())
{
// +++ Item
wsprintf(s, _T("[%02u] Skip"), iOrd);
} else
{
// --- Item
wsprintf(s, _T("[%02u] Stop"), iOrd);
}
}
LPARAM param = (seq << SEQU_SHIFT) | iOrd;
if(info.tiOrders[seq][iOrd])
{
tvi.mask = TVIF_TEXT | TVIF_HANDLE | TVIF_STATE;
tvi.state = 0;
tvi.stateMask = TVIS_BOLD;
tvi.hItem = info.tiOrders[seq][iOrd];
tvi.pszText = stmp;
tvi.cchTextMax = mpt::saturate_cast<int>(std::size(stmp));
GetItem(&tvi);
if(tvi.state != state || _tcscmp(s, stmp))
SetItem(info.tiOrders[seq][iOrd], TVIF_TEXT | TVIF_STATE | TVIF_PARAM, s, 0, 0, state, TVIS_BOLD, param);
} else
{
info.tiOrders[seq][iOrd] = InsertItem(TVIF_HANDLE | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM, s, IMAGE_PARTITION, IMAGE_PARTITION, 0, 0, param, hAncestorNode, TVI_LAST);
}
}
}
}
// Add Patterns
if(info.hPatterns && patternHint.GetType()[HINT_MODTYPE | HINT_PATNAMES])
{
const PATTERNINDEX nPat = patternHint.GetPattern();
PATTERNINDEX minPat = 0, maxPat = sndFile.Patterns.Size();
if(patternHint.GetType()[HINT_PATNAMES] && nPat < sndFile.Patterns.Size())
{
minPat = nPat;
maxPat = nPat + 1;
}
for(size_t pat = sndFile.Patterns.Size(); pat < info.tiPatterns.size(); pat++)
{
DeleteItem(info.tiPatterns[pat]);
}
info.tiPatterns.resize(sndFile.Patterns.Size(), nullptr);
mpt::winstring patName;
for(PATTERNINDEX pat = minPat; pat < maxPat; pat++)
{
TCHAR s[256];
s[0] = 0;
if(sndFile.Patterns.IsValidPat(pat))
{
patName = mpt::ToWin(sndFile.GetCharsetInternal(), sndFile.Patterns[pat].GetName());
wsprintf(s, _T("%u"), pat);
if(!patName.empty())
{
_tcscat(s, _T(": "));
_tcscat(s, patName.c_str());
}
if(info.tiPatterns[pat])
{
tvi.mask = TVIF_TEXT | TVIF_HANDLE;
tvi.hItem = info.tiPatterns[pat];
tvi.pszText = stmp;
tvi.cchTextMax = mpt::saturate_cast<int>(std::size(stmp));
GetItem(&tvi);
if(_tcscmp(s, stmp))
SetItem(info.tiPatterns[pat], TVIF_TEXT, s, 0, 0, 0, 0, 0);
} else
{
info.tiPatterns[pat] = InsertItem(s, IMAGE_PATTERNS, IMAGE_PATTERNS, info.hPatterns, TVI_LAST);
}
SetItemData(info.tiPatterns[pat], pat);
} else if(pat < info.tiPatterns.size() && info.tiPatterns[pat])
{
DeleteItem(info.tiPatterns[pat]);
info.tiPatterns[pat] = nullptr;
}
}
}
// Add Samples
const SampleHint sampleHint = hint.ToType<SampleHint>();
if(info.hSamples && sampleHint.GetType()[HINT_MODTYPE | HINT_SMPNAMES | HINT_SAMPLEINFO | HINT_SAMPLEDATA])
{
const SAMPLEINDEX hintSmp = sampleHint.GetSample();
SAMPLEINDEX smin = 1, smax = MAX_SAMPLES - 1;
if(sampleHint.GetType()[HINT_SMPNAMES | HINT_SAMPLEINFO | HINT_SAMPLEDATA] && hintSmp > 0 && hintSmp < MAX_SAMPLES)
{
smin = smax = hintSmp;
}
HTREEITEM hChild = GetNthChildItem(info.hSamples, smin - 1);
for(SAMPLEINDEX nSmp = smin; nSmp <= smax; nSmp++)
{
TCHAR s[256];
s[0] = 0;
HTREEITEM hNextChild = GetNextSiblingItem(hChild);
if(nSmp <= sndFile.GetNumSamples())
{
const ModSample &sample = sndFile.GetSample(nSmp);
const bool sampleExists = (sample.HasSampleData());
static constexpr int Images[] =
{
IMAGE_NOSAMPLE, IMAGE_NOSAMPLE, IMAGE_NOSAMPLE,
IMAGE_SAMPLES, IMAGE_SAMPLEACTIVE, IMAGE_SAMPLEMUTE,
IMAGE_EXTSAMPLE, IMAGE_EXTSAMPLEACTIVE, IMAGE_EXTSAMPLEMUTE,
IMAGE_OPLINSTR, IMAGE_OPLINSTRACTIVE, IMAGE_OPLINSTRMUTE,
};
int image = 0;
if(sampleExists)
image = 3;
if(sample.uFlags[SMP_KEEPONDISK])
image = 6;
if(sample.uFlags[CHN_ADLIB])
image = 9;
if(info.modDoc.IsSampleMuted(nSmp))
image += 2;
else if(info.samplesPlaying[nSmp])
image++;
if(sample.uFlags[SMP_KEEPONDISK] && !sampleExists)
image = IMAGE_EXTSAMPLEMISSING;
else
image = Images[image];
if(sndFile.GetType() == MOD_TYPE_MPT)
{
const TCHAR *status = _T("");
if(sample.uFlags[SMP_KEEPONDISK])
{
status = sampleExists ? _T(" [external]") : _T(" [MISSING]");
}
wsprintf(s, _T("%3d: %s%s%s"), nSmp, sample.uFlags.test_all(SMP_MODIFIED | SMP_KEEPONDISK) ? _T("* ") : _T(""), mpt::ToCString(sndFile.GetCharsetInternal(), sndFile.m_szNames[nSmp]).GetString(), status);
} else
{
wsprintf(s, _T("%3d: %s"), nSmp, mpt::ToCString(sndFile.GetCharsetInternal(), sndFile.m_szNames[nSmp]).GetString());
}
if(!hChild)
{
hChild = InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM, s, image, image, 0, 0, nSmp, info.hSamples, TVI_LAST);
} else
{
tvi.mask = TVIF_TEXT | TVIF_HANDLE | TVIF_IMAGE;
tvi.hItem = hChild;
tvi.pszText = stmp;
tvi.cchTextMax = mpt::saturate_cast<int>(std::size(stmp));
tvi.iImage = tvi.iSelectedImage = image;
GetItem(&tvi);
if(tvi.iImage != image || _tcsncmp(s, stmp, std::size(stmp)) || GetItemData(hChild) != nSmp)
{
SetItem(hChild, TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM, s, image, image, 0, 0, nSmp);
}
}
} else if(hChild != nullptr)
{
DeleteItem(hChild);
} else
{
break;
}
hChild = hNextChild;
}
}
// Add Instruments
const InstrumentHint instrHint = hint.ToType<InstrumentHint>();
if(info.hInstruments && instrHint.GetType()[HINT_MODTYPE | HINT_INSNAMES | HINT_INSTRUMENT])
{
INSTRUMENTINDEX smin = 1, smax = MAX_INSTRUMENTS - 1;
const INSTRUMENTINDEX hintIns = instrHint.GetInstrument();
if(instrHint.GetType()[HINT_INSNAMES | HINT_INSTRUMENT] && hintIns > 0 && hintIns < MAX_INSTRUMENTS)
{
smin = smax = hintIns;
}
HTREEITEM hChild = GetNthChildItem(info.hInstruments, smin - 1);
for(INSTRUMENTINDEX nIns = smin; nIns <= smax; nIns++)
{
TCHAR s[256];
s[0] = 0;
HTREEITEM hNextChild = GetNextSiblingItem(hChild);
if(nIns <= sndFile.GetNumInstruments())
{
wsprintf(s, _T("%3u: %s"), nIns, mpt::ToCString(sndFile.GetCharsetInternal(), sndFile.GetInstrumentName(nIns)).GetString());
int nImage = IMAGE_INSTRUMENTS;
if(info.instrumentsPlaying[nIns])
nImage = IMAGE_INSTRACTIVE;
if(!sndFile.Instruments[nIns] || info.modDoc.IsInstrumentMuted(nIns))
nImage = IMAGE_INSTRMUTE;
if(!hChild)
{
hChild = InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM, s, nImage, nImage, 0, 0, nIns, info.hInstruments, TVI_LAST);
} else
{
tvi.mask = TVIF_TEXT | TVIF_HANDLE | TVIF_IMAGE;
tvi.hItem = hChild;
tvi.pszText = stmp;
tvi.cchTextMax = mpt::saturate_cast<int>(std::size(stmp));
tvi.iImage = tvi.iSelectedImage = nImage;
GetItem(&tvi);
if(tvi.iImage != nImage || _tcscmp(s, stmp) || GetItemData(hChild) != nIns)
{
SetItem(hChild, TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM, s, nImage, nImage, 0, 0, nIns);
}
}
} else if(hChild != nullptr)
{
DeleteItem(hChild);
} else
{
break;
}
hChild = hNextChild;
}
}
}
CModTree::ModItem CModTree::GetModItem(HTREEITEM hItem)
{
if(!hItem)
return ModItem(MODITEM_NULL);
// First, test root items
if(hItem == m_hInsLib)
return ModItem(MODITEM_HDR_INSTRUMENTLIB);
if(hItem == m_hMidiLib)
return ModItem(MODITEM_HDR_MIDILIB);
// The immediate parent of the item (NULL if this item is on the root level of the tree)
HTREEITEM hItemParent = GetParentItem(hItem);
// Parent of the parent.
HTREEITEM hItemParentParent = GetParentItem(hItemParent);
// Get the root parent of the selected item, which can be the item itself.
HTREEITEM hRootParent = hItem;
if(!IsSampleBrowser())
{
hRootParent = GetParentRootItem(hItem);
}
uint32 itemData = static_cast<uint32>(GetItemData(hItem));
uint32 rootItemData = static_cast<uint32>(GetItemData(hRootParent));
// Midi Library
if(hRootParent == m_hMidiLib && hRootParent != hItem && !IsSampleBrowser())
{
return ModItem(static_cast<ModItemType>(itemData >> MIDILIB_SHIFT), itemData & MIDILIB_MASK);
}
// Instrument Library
if(hRootParent == m_hInsLib || (IsSampleBrowser() && hItem != m_hInsLib))
{
TVITEM tvi;
tvi.mask = TVIF_IMAGE | TVIF_HANDLE;
tvi.hItem = hItem;
tvi.iImage = 0;
if(GetItem(&tvi))
{
switch(tvi.iImage)
{
case IMAGE_SAMPLES:
case IMAGE_OPLINSTR:
// Sample
return ModItem(MODITEM_INSLIB_SAMPLE);
case IMAGE_INSTRUMENTS:
// Instrument
return ModItem(MODITEM_INSLIB_INSTRUMENT);
case IMAGE_FOLDERSONG:
// Song
return ModItem(MODITEM_INSLIB_SONG);
default:
return ModItem(MODITEM_INSLIB_FOLDER);
}
}
return ModItem(MODITEM_NULL);
}
if(IsSampleBrowser())
return ModItem(MODITEM_NULL);
// Songs
if(auto info = GetDocumentInfoFromItem(hRootParent); info != nullptr)
{
m_selectedDoc = &info->modDoc;
if(hItem == info->hSong)
return ModItem(MODITEM_HDR_SONG);
if(hRootParent == info->hSong)
{
if(hItem == info->hPatterns)
return ModItem(MODITEM_HDR_PATTERNS);
if(hItem == info->hOrders)
return ModItem(MODITEM_HDR_ORDERS);
if(hItem == info->hSamples)
return ModItem(MODITEM_HDR_SAMPLES);
if(hItem == info->hInstruments)
return ModItem(MODITEM_HDR_INSTRUMENTS);
if(hItem == info->hEffects)
return ModItem(MODITEM_HDR_EFFECTS);
if(hItem == info->hComments)
return ModItem(MODITEM_COMMENTS);
// Order List or Sequence item?
if((hItemParent == info->hOrders) || (hItemParentParent == info->hOrders))
{
const auto ord = static_cast<ORDERINDEX>(itemData & SEQU_MASK);
const auto seq = static_cast<SEQUENCEINDEX>(itemData >> SEQU_SHIFT);
if(ord == ORDERINDEX_INVALID)
return ModItem(MODITEM_SEQUENCE, seq);
else
return ModItem(MODITEM_ORDER, ord, seq);
}
ModItem modItem(MODITEM_NULL, itemData);
if(hItemParent == info->hPatterns)
{
// Pattern
modItem.type = MODITEM_PATTERN;
} else if(hItemParent == info->hSamples)
{
// Sample
modItem.type = MODITEM_SAMPLE;
} else if(hItemParent == info->hInstruments)
{
// Instrument
modItem.type = MODITEM_INSTRUMENT;
} else if(hItemParent == info->hEffects)
{
// Effect
modItem.type = MODITEM_EFFECT;
}
return modItem;
}
}
// DLS banks
if(itemData < m_tiDLS.size() && hItem == m_tiDLS[itemData])
return ModItem(MODITEM_DLSBANK_FOLDER, itemData);
// DLS Instruments
if(hRootParent != nullptr)
{
if(rootItemData < m_tiDLS.size() && m_tiDLS[rootItemData] == hRootParent)
{
int image = 0, selImage = 0;
const bool isFolder = GetItemImage(hItem, image, selImage) && (image == IMAGE_FOLDER || image == IMAGE_OPENFOLDER);
if(!isFolder || GetItemData(hItemParent) == DLS_DRUM_FOLDER_LPARAM)
return DlsItem::FromLPARAM(itemData);
}
}
return ModItem(MODITEM_NULL);
}
bool CModTree::ExecuteItem(HTREEITEM hItem)
{
if(hItem)
{
const ModItem modItem = GetModItem(hItem);
uint32 modItemID = modItem.val1;
CModDoc *modDoc = m_docInfo.count(m_selectedDoc) ? m_selectedDoc : nullptr;
switch(modItem.type)
{
case MODITEM_COMMENTS:
if(modDoc)
modDoc->ActivateView(IDD_CONTROL_COMMENTS, 0);
return true;
case MODITEM_SEQUENCE:
if(modDoc
&& modItemID < modDoc->GetSoundFile().Order.GetNumSequences()
&& !modDoc->GetSoundFile().Order(static_cast<SEQUENCEINDEX>(modItemID)).GetLengthTailTrimmed())
modDoc->ActivateView(IDD_CONTROL_PATTERNS, (modItemID << SEQU_SHIFT) | SEQU_INDICATOR);
return true;
case MODITEM_ORDER:
if(modDoc)
modDoc->ActivateView(IDD_CONTROL_PATTERNS, modItemID | (uint32(modItem.val2) << SEQU_SHIFT) | SEQU_INDICATOR);
return true;
case MODITEM_PATTERN:
if(modDoc)
modDoc->ActivateView(IDD_CONTROL_PATTERNS, modItemID);
return true;
case MODITEM_SAMPLE:
if(modDoc)
modDoc->ActivateView(IDD_CONTROL_SAMPLES, modItemID);
return true;
case MODITEM_INSTRUMENT:
if(modDoc)
modDoc->ActivateView(IDD_CONTROL_INSTRUMENTS, modItemID);
return true;
case MODITEM_MIDIPERCUSSION:
modItemID |= 0x80;
[[fallthrough]];
case MODITEM_MIDIINSTRUMENT:
OpenMidiInstrument(modItemID);
return true;
case MODITEM_EFFECT:
case MODITEM_INSLIB_SAMPLE:
case MODITEM_INSLIB_INSTRUMENT:
PlayItem(hItem, NOTE_MIDDLEC);
return true;
case MODITEM_INSLIB_SONG:
case MODITEM_INSLIB_FOLDER:
// If it's a shell link, resolve the link target
if(auto file = LinkResolver().Resolve(m_InstrLibPath.ToCString() + GetItemText(hItem)); !file.empty())
{
SetFullInstrumentLibraryPath(file);
} else
{
InstrumentLibraryChDir(mpt::PathString::FromCString(GetItemText(hItem)), modItem.type == MODITEM_INSLIB_SONG);
}
return true;
case MODITEM_HDR_SONG:
if(modDoc)
modDoc->ActivateWindow();
return true;
case MODITEM_DLSBANK_INSTRUMENT:
if(GetItemData(GetParentItem(hItem)) != DLS_DRUM_FOLDER_LPARAM)
PlayItem(hItem, NOTE_MIDDLEC);
return true;
case MODITEM_HDR_INSTRUMENTLIB:
if(IsSampleBrowser())
{
BrowseForFolder dlg(m_InstrLibPath, _T("Select a new instrument library folder..."));
if(dlg.Show())
{
SetFullInstrumentLibraryPath(dlg.GetDirectory());
}
}
return true;
}
}
return false;
}
void CModTree::PlayDLSItem(const CDLSBank &dlsBank, const DlsItem &item, ModCommand::NOTE note)
{
UINT rgn, instr = item.GetInstr();
if(item.IsPercussion())
rgn = item.GetRegion();
else
rgn = dlsBank.GetRegionFromKey(instr, note - NOTE_MIN);
CMainFrame::GetMainFrame()->PlayDLSInstrument(dlsBank, instr, rgn, note);
}
BOOL CModTree::PlayItem(HTREEITEM hItem, ModCommand::NOTE note, int volume)
{
if(hItem)
{
const ModItem modItem = GetModItem(hItem);
uint32 modItemID = modItem.val1;
CModDoc *modDoc = m_docInfo.count(m_selectedDoc) ? m_selectedDoc : nullptr;
switch(modItem.type)
{
case MODITEM_SAMPLE:
if(modDoc)
{
if(note == NOTE_NOTECUT)
{
modDoc->NoteOff(0, true); // cut previous playing samples
} else if(note & 0x80)
{
modDoc->NoteOff(note & 0x7F, true);
} else
{
modDoc->NoteOff(0, true); // cut previous playing samples
modDoc->PlayNote(PlayNoteParam(note & 0x7F).Sample(static_cast<SAMPLEINDEX>(modItemID)).Volume(volume));
}
}
return TRUE;
case MODITEM_INSTRUMENT:
if(modDoc)
{
if(note == NOTE_NOTECUT)
{
modDoc->NoteOff(0, true);
} else if(note & 0x80)
{
modDoc->NoteOff(note & 0x7F, true);
} else
{
modDoc->NoteOff(0, true);
modDoc->PlayNote(PlayNoteParam(note & 0x7F).Instrument(static_cast<INSTRUMENTINDEX>(modItemID)).Volume(volume));
}
}
return TRUE;
case MODITEM_EFFECT:
if((modDoc) && (modItemID < MAX_MIXPLUGINS))
{
modDoc->TogglePluginEditor(modItemID);
}
return TRUE;
case MODITEM_INSLIB_SAMPLE:
case MODITEM_INSLIB_INSTRUMENT:
if(note != NOTE_NOTECUT)
{
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
if(!m_SongFileName.empty())
{
// Preview sample / instrument in module
const size_t n = ConvertStrTo<size_t>(GetItemText(hItem));
if(pMainFrm && m_SongFile)
{
if(modItem.type == MODITEM_INSLIB_INSTRUMENT)
{
pMainFrm->PlaySoundFile(*m_SongFile, static_cast<INSTRUMENTINDEX>(n), SAMPLEINDEX_INVALID, note, volume);
} else
{
pMainFrm->PlaySoundFile(*m_SongFile, INSTRUMENTINDEX_INVALID, static_cast<SAMPLEINDEX>(n), note, volume);
}
}
} else
{
// Preview sample / instrument file
auto file = InsLibGetFullPath(hItem);
// If it's a shell link, resolve the link target
if(auto resolvedName = LinkResolver().Resolve(file.AsNative().c_str()); !resolvedName.empty())
file = std::move(resolvedName);
if(pMainFrm)
pMainFrm->PlaySoundFile(file, note, volume);
}
} else
{
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
if(pMainFrm)
pMainFrm->StopPreview();
}
return TRUE;
case MODITEM_MIDIPERCUSSION:
modItemID |= 0x80;
[[fallthrough]];
case MODITEM_MIDIINSTRUMENT:
{
const MidiLibrary &midiLib = CTrackApp::GetMidiLibrary();
if(modItemID < midiLib.size() && !midiLib[modItemID].empty())
{
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
CDLSBank *dlsBank = nullptr;
if(!mpt::PathString::CompareNoCase(m_cachedBankName, midiLib[modItemID]))
{
dlsBank = m_cachedBank.get();
}
if(dlsBank == nullptr && CDLSBank::IsDLSBank(midiLib[modItemID]))
{
m_cachedBank = std::make_unique<CDLSBank>();
if(m_cachedBank->Open(midiLib[modItemID]))
{
m_cachedBankName = midiLib[modItemID];
dlsBank = m_cachedBank.get();
}
}
if(dlsBank != nullptr)
{
uint32 item = 0;
if(modItemID < 0x80)
{
dlsBank->FindInstrument(false, 0xFFFF, modItemID, note - NOTE_MIN, &item);
PlayDLSItem(*dlsBank, DlsItem(static_cast<uint16>(item)), note);
} else
{
dlsBank->FindInstrument(true, 0xFFFF, 0xFF, modItemID & 0x7F, &item);
PlayDLSItem(*dlsBank, DlsItem(static_cast<uint16>(item), static_cast<uint16>(dlsBank->GetRegionFromKey(item, modItemID & 0x7F))), note);
}
} else
{
pMainFrm->PlaySoundFile(midiLib[modItemID], note, volume);
}
}
}
return TRUE;
case MODITEM_DLSBANK_INSTRUMENT:
{
const DlsItem &item = static_cast<const DlsItem &>(modItem);
CDLSBank *dlsBank = GetDLSBankFromItem(hItem);
if(dlsBank != nullptr)
{
PlayDLSItem(*dlsBank, item, note);
return TRUE;
}
}
}
}
return FALSE;
}
BOOL CModTree::SetMidiInstrument(UINT nIns, const mpt::PathString &fileName)
{
MidiLibrary &midiLib = CTrackApp::GetMidiLibrary();
if(nIns < 128)
{
midiLib[nIns] = fileName;
RefreshMidiLibrary();
return TRUE;
}
return FALSE;
}
BOOL CModTree::SetMidiPercussion(UINT nPerc, const mpt::PathString &fileName)
{
MidiLibrary &midiLib = CTrackApp::GetMidiLibrary();
if(nPerc < 128)
{
UINT nIns = nPerc | 0x80;
midiLib[nIns] = fileName;
RefreshMidiLibrary();
return TRUE;
}
return FALSE;
}
static mpt::ustring TreeDeletionString(const mpt::uchar *type, uint32 id, const mpt::ustring &name)
{
mpt::ustring s = MPT_UFORMAT("Remove {} {}")(mpt::ustring(type), id);
if(!name.empty())
s += U_(": ") + name;
s.append(1, UC_('?'));
return s;
}
void CModTree::DeleteTreeItem(HTREEITEM hItem)
{
const ModItem modItem = GetModItem(hItem);
uint32 modItemID = modItem.val1;
CModDoc *modDoc = m_docInfo.count(m_selectedDoc) ? m_selectedDoc : nullptr;
CSoundFile *sndFile = modDoc ? &modDoc->GetSoundFile() : nullptr;
if(modItem.IsSongItem() && modDoc == nullptr)
{
return;
}
switch(modItem.type)
{
case MODITEM_SEQUENCE:
if(sndFile)
{
const SEQUENCEINDEX seq = static_cast<SEQUENCEINDEX>(modItemID);
if(Reporting::Confirm(TreeDeletionString(UL_("sequence"), seq + 1, sndFile->Order(seq).GetName()), false, true) == cnfNo) break;
sndFile->Order.RemoveSequence(seq);
modDoc->UpdateAllViews(nullptr, SequenceHint().Data());
}
break;
case MODITEM_ORDER:
// might be slightly annoying to ask for confirmation here, and it's rather easy to restore the orderlist anyway.
if(modDoc && modDoc->RemoveOrder(static_cast<SEQUENCEINDEX>(modItem.val2), static_cast<ORDERINDEX>(modItem.val1)))
{
modDoc->UpdateAllViews(nullptr, SequenceHint().Data());
}
break;
case MODITEM_PATTERN:
if(modDoc && sndFile)
{
const PATTERNINDEX pat = static_cast<PATTERNINDEX>(modItemID);
bool isUsed = false;
// First, find all used patterns in all sequences.
for(const auto &sequence : sndFile->Order)
{
if(sequence.FindOrder(pat) != ORDERINDEX_INVALID)
{
isUsed = true;
break;
}
}
mpt::ustring s = TreeDeletionString(UL_("pattern"), modItemID, mpt::ToUnicode(sndFile->GetCharsetInternal(), sndFile->Patterns[pat].GetName()));
s += MPT_UFORMAT("\nThis pattern is currently {}used.")(isUsed ? U_("") : U_("un"));
if(Reporting::Confirm(s, false, isUsed) == cnfYes && modDoc->RemovePattern(pat))
{
modDoc->UpdateAllViews(nullptr, PatternHint(pat).Data().Names());
if(isUsed)
modDoc->UpdateAllViews(nullptr, SequenceHint().Data()); // Pattern color will change in sequence
}
}
break;
case MODITEM_SAMPLE:
if(modDoc && sndFile)
{
if(!sndFile->GetSample(static_cast<SAMPLEINDEX>(modItemID)).HasSampleData()
|| Reporting::Confirm(TreeDeletionString(UL_("sample"), modItemID, mpt::ToUnicode(sndFile->GetCharsetInternal(), sndFile->m_szNames[modItemID])), false, true) == cnfYes)
{
const SAMPLEINDEX smp = static_cast<SAMPLEINDEX>(modItemID);
modDoc->GetSampleUndo().PrepareUndo(smp, sundo_replace, "Delete");
const SAMPLEINDEX oldNumSamples = modDoc->GetNumSamples();
if(modDoc->RemoveSample(smp))
{
modDoc->UpdateAllViews(nullptr, SampleHint(modDoc->GetNumSamples() != oldNumSamples ? 0 : smp).Info().Data().Names());
}
}
}
break;
case MODITEM_INSTRUMENT:
if(modDoc && sndFile)
{
if(sndFile->Instruments[modItemID] == nullptr
|| Reporting::Confirm(TreeDeletionString(UL_("instrument"), modItemID, mpt::ToUnicode(sndFile->GetCharsetInternal(), sndFile->Instruments[modItemID]->name)), false, true) == cnfYes)
{
const INSTRUMENTINDEX ins = static_cast<INSTRUMENTINDEX>(modItemID);
modDoc->GetInstrumentUndo().PrepareUndo(ins, "Delete");
const INSTRUMENTINDEX oldNumInstrs = modDoc->GetNumInstruments();
if(modDoc->RemoveInstrument(ins))
{
modDoc->UpdateAllViews(nullptr, InstrumentHint(modDoc->GetNumInstruments() != oldNumInstrs ? 0 : ins).Info().Envelope().ModType());
}
}
}
break;
case MODITEM_EFFECT:
if(modDoc && Reporting::Confirm(TreeDeletionString(UL_("plugin FX"), modItemID + 1, sndFile->m_MixPlugins[modItemID].GetName()), false, true) == cnfYes)
{
modDoc->RemovePlugin(static_cast<PLUGINDEX>(modItemID));
}
break;
case MODITEM_MIDIINSTRUMENT:
SetMidiInstrument(modItemID, P_(""));
RefreshMidiLibrary();
break;
case MODITEM_MIDIPERCUSSION:
SetMidiPercussion(modItemID, P_(""));
RefreshMidiLibrary();
break;
case MODITEM_DLSBANK_FOLDER:
CTrackApp::RemoveDLSBank(modItemID);
RefreshDlsBanks();
break;
case MODITEM_INSLIB_SONG:
case MODITEM_INSLIB_SAMPLE:
case MODITEM_INSLIB_INSTRUMENT:
{
// Create double-null-terminated path
const mpt::winstring fullPath = InsLibGetFullPath(hItem).AsNative() + _T('\0');
SHFILEOPSTRUCT fos;
MemsetZero(fos);
fos.hwnd = m_hWnd;
fos.wFunc = FO_DELETE;
fos.pFrom = fullPath.c_str();
fos.fFlags = CMainFrame::GetInputHandler()->ShiftPressed() ? 0 : FOF_ALLOWUNDO;
if(!SHFileOperation(&fos) && !fos.fAnyOperationsAborted)
{
HTREEITEM newSel = GetNextSiblingItem(hItem);
if(!newSel) newSel = GetPrevSiblingItem(hItem);
SelectItem(newSel);
RefreshInstrumentLibrary();
SetFocus();
}
}
break;
}
}
BOOL CModTree::OpenTreeItem(HTREEITEM hItem)
{
const ModItem modItem = GetModItem(hItem);
switch(modItem.type)
{
case MODITEM_INSLIB_SONG:
theApp.OpenDocumentFile(InsLibGetFullPath(hItem).ToCString());
break;
case MODITEM_HDR_INSTRUMENTLIB:
CTrackApp::OpenDirectory(m_InstrLibPath);
break;
case MODITEM_INSLIB_FOLDER:
// Open path in Explorer
CTrackApp::OpenDirectory(InsLibGetFullPath(hItem));
break;
}
return TRUE;
}
BOOL CModTree::OpenMidiInstrument(DWORD dwItem)
{
std::vector<FileType> mediaFoundationTypes = CSoundFile::GetMediaFoundationFileTypes();
FileDialog dlg = OpenFileDialog()
.EnableAudioPreview()
.ExtensionFilter(
"All Instruments and Banks (*.xi,*.pat,*.iti,*.sfz,*.dls,*.sf2,...)|*.xi;*.pat;*.iti;*.sfz;*.wav;*.w64;*.caf;*.aif;*.aiff;*.sbk;*.sf2;*.sf3;*.sf4;*.dls;*.mss;*.flac;*.opus;*.ogg;*.oga;*.mp1;*.mp2;*.mp3" + ToFilterOnlyString(mediaFoundationTypes, true).ToLocale() + "|"
"FastTracker II Instruments (*.xi)|*.xi|"
"GF1 Patches (*.pat)|*.pat|"
"Wave Files (*.wav)|*.wav|"
"Wave64 Files (*.w64)|*.w64|"
"CAF Files (*.caf)|*.caf|"
#ifdef MPT_WITH_FLAC
"FLAC Files (*.flac,*.oga)|*.flac;*.oga|"
#endif // MPT_WITH_FLAC
#if defined(MPT_WITH_OPUSFILE)
"Opus Files (*.opus,*.oga)|*.opus;*.oga|"
#endif // MPT_WITH_OPUSFILE
#if defined(MPT_WITH_VORBISFILE) || defined(MPT_WITH_STBVORBIS)
"Ogg Vorbis Files (*.ogg,*.oga)|*.ogg;*.oga|"
#endif // VORBIS
#if defined(MPT_ENABLE_MP3_SAMPLES)
"MPEG Files (*.mp1,*.mp2,*.mp3)|*.mp1;*.mp2;*.mp3|"
#endif // MPT_ENABLE_MP3_SAMPLES
#if defined(MPT_WITH_MEDIAFOUNDATION)
+ ToFilterString(mediaFoundationTypes, FileTypeFormatShowExtensions).ToLocale() +
#endif
"Impulse Tracker Instruments (*.iti)|*.iti;*.its|"
"SFZ Instruments (*.sfz)|*.sfz|"
"SoundFont 2.0 Banks (*.sf2)|*.sbk;*.sf2;*.sf3;*.sf4|"
"DLS Sound Banks (*.dls;*.mss)|*.dls;*.mss|"
"All Files (*.*)|*.*||");
if(!dlg.Show()) return FALSE;
if(dwItem & 0x80)
return SetMidiPercussion(dwItem & 0x7F, dlg.GetFirstFile());
else
return SetMidiInstrument(dwItem, dlg.GetFirstFile());
}
// Empty Instrument Library
void CModTree::EmptyInstrumentLibrary()
{
HTREEITEM h;
if(!m_hInsLib)
return;
if(!IsSampleBrowser())
{
DeleteChildren(m_hInsLib);
} else
{
while((h = GetNextItem(m_hInsLib, TVGN_NEXT)) != NULL)
{
DeleteItem(h);
}
}
}
// Refresh Instrument Library
void CModTree::FillInstrumentLibrary(const TCHAR *selectedItem)
{
if(!m_hInsLib)
return;
SetRedraw(FALSE);
if(!m_SongFileName.empty() && IsSampleBrowser() && m_SongFile)
{
// Fill browser with samples / instruments of module file
SetItemText(m_hInsLib, m_SongFileName.AsNative().c_str());
SetItemImage(m_hInsLib, IMAGE_FOLDERSONG, IMAGE_FOLDERSONG);
for(INSTRUMENTINDEX ins = 1; ins <= m_SongFile->GetNumInstruments(); ins++)
{
ModInstrument *pIns = m_SongFile->Instruments[ins];
if(pIns)
{
TCHAR s[MAX_INSTRUMENTNAME + 10];
_sntprintf(s, std::size(s), _T("%3d: %s"), ins, mpt::ToWin(m_SongFile->GetCharsetInternal(), pIns->name).c_str());
InsertInsLibItem(s, IMAGE_INSTRUMENTS, selectedItem);
}
}
for(SAMPLEINDEX smp = 1; smp <= m_SongFile->GetNumSamples(); smp++)
{
const ModSample &sample = m_SongFile->GetSample(smp);
if(sample.HasSampleData() || sample.uFlags[CHN_ADLIB])
{
TCHAR s[MAX_SAMPLENAME + 10];
_sntprintf(s, std::size(s), _T("%3d: %s"), smp, mpt::ToWin(m_SongFile->GetCharsetInternal(), m_SongFile->m_szNames[smp]).c_str());
InsertInsLibItem(s, sample.uFlags[CHN_ADLIB] ? IMAGE_OPLINSTR : IMAGE_SAMPLES, selectedItem);
}
}
} else if(!m_InstrLibPath.empty())
{
if(!IsSampleBrowser())
{
SetItemText(m_hInsLib, _T("Instrument Library (") + m_InstrLibPath.ToCString() + _T(")"));
} else
{
SetItemText(m_hInsLib, m_InstrLibPath.ToCString());
SetItemImage(m_hInsLib, IMAGE_FOLDER, IMAGE_FOLDER);
}
// Enumerating Drives...
if(!IsSampleBrowser())
{
CImageList &images = CMainFrame::GetMainFrame()->m_MiscIcons;
// Avoid adding the same images again and again...
images.SetImageCount(IMGLIST_NUMIMAGES);
TCHAR s[] = _T("?:\\");
for(int drive = 'A'; drive <= 'Z'; drive++)
{
s[0] = static_cast<TCHAR>(drive);
auto driveType = GetDriveType(s);
if(driveType != DRIVE_UNKNOWN && driveType != DRIVE_NO_ROOT_DIR)
{
if(driveType == DRIVE_REMOVABLE)
{
TCHAR sDevice[] = _T("\\\\.\\?:");
sDevice[4] = s[0];
auto hDevice = CreateFile(sDevice, FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
if(hDevice != INVALID_HANDLE_VALUE)
{
// Check if removable media is inserted
DWORD bytesReturned = 0;
auto success = DeviceIoControl(hDevice, IOCTL_STORAGE_CHECK_VERIFY2, nullptr, 0, nullptr, 0, &bytesReturned, nullptr);
CloseHandle(hDevice);
if(!success && GetLastError() == ERROR_NOT_READY)
continue;
}
}
SHFILEINFO fileInfo;
SHGetFileInfo(s, 0, &fileInfo, sizeof(fileInfo), SHGFI_ICON | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES); // SHGFI_USEFILEATTRIBUTES speeds up retrieval for offline network shares
const int imageIndex = fileInfo.hIcon ? images.Add(fileInfo.hIcon) : IMAGE_FOLDER;
InsertInsLibItem(s, imageIndex < 0 ? IMAGE_FOLDER : imageIndex, selectedItem);
DestroyIcon(fileInfo.hIcon);
}
}
}
// Enumerating Directories and samples/instruments
const mpt::PathString path = m_InstrLibPath + P_("*.*");
const bool showDirs = !IsSampleBrowser() || TrackerSettings::Instance().showDirsInSampleBrowser;
const bool showInstrs = IsSampleBrowser();
enum
{
FILTER_FIRST_VALID = 0,
FILTER_REJECT_FILE = -1,
FILTER_UNKNOWN_FILE = -2,
};
const auto FilterFile = [this, showInstrs, showDirs](const mpt::PathString &fileName) -> int
{
static constexpr auto instrExts = {"xi", "iti", "sfz", "sf2", "sf3", "sf4", "sbk", "dls", "mss", "pat"};
static constexpr auto sampleExts = {"wav", "flac", "ogg", "opus", "mp1", "mp2", "mp3", "smp", "raw", "s3i", "its", "aif", "aiff", "au", "snd", "svx", "voc", "8sv", "8svx", "16sv", "16svx", "w64", "caf", "sb0", "sb2", "sbi"};
static constexpr auto allExtsBlacklist = {"txt", "diz", "nfo", "doc", "ini", "pdf", "zip", "rar", "lha", "exe", "dll", "lnk", "url"};
// Get lower-case file extension without dot.
mpt::PathString extPS = fileName.GetFileExt();
std::string ext = extPS.ToUTF8();
if(!ext.empty())
{
ext.erase(0, 1);
ext = mpt::ToLowerCaseAscii(ext);
extPS = mpt::PathString::FromUTF8(ext);
}
bool knownExtension = true;
if(mpt::contains(instrExts, ext))
{
if(showInstrs)
return IMAGE_INSTRUMENTS;
} else if(mpt::contains(sampleExts, ext))
{
if(showInstrs)
return IMAGE_SAMPLES;
} else if(mpt::contains(m_modExtensions, ext))
{
if(showDirs || m_showAllFiles)
return IMAGE_FOLDERSONG;
} else if(!extPS.empty() && mpt::contains(m_MediaFoundationExtensions, extPS))
{
if(showInstrs)
return IMAGE_SAMPLES;
} else
{
if(showDirs)
{
// Amiga-style prefix (i.e. mod.songname)
std::string prefixExt = fileName.ToUTF8();
const auto dotPos = prefixExt.find('.');
if(dotPos != std::string::npos && mpt::contains(m_modExtensions, prefixExt.erase(dotPos)))
return IMAGE_FOLDERSONG;
}
knownExtension = false;
}
if(m_showAllFiles && !mpt::contains(allExtsBlacklist, ext))
return IMAGE_SAMPLES;
return knownExtension ? FILTER_REJECT_FILE : FILTER_UNKNOWN_FILE;
};
HKEY hkey = nullptr;
bool showHidden = false;
if(auto cr = RegOpenKeyEx(HKEY_CURRENT_USER, _T("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced"), 0, KEY_READ, &hkey); cr == ERROR_SUCCESS)
{
DWORD dataType = REG_NONE;
DWORD data = 0, datasize = sizeof(data);
if(RegQueryValueEx(hkey, _T("Hidden"), 0, &dataType, reinterpret_cast<BYTE *>(&data), &datasize) == ERROR_SUCCESS && dataType == REG_DWORD)
showHidden = (data == 1);
RegCloseKey(hkey);
}
LinkResolver linkResolver;
HANDLE hFind;
WIN32_FIND_DATA wfd;
MemsetZero(wfd);
if((hFind = FindFirstFile(path.AsNative().c_str(), &wfd)) != INVALID_HANDLE_VALUE)
{
do
{
// Up Directory
int type = FILTER_REJECT_FILE;
if(!_tcscmp(wfd.cFileName, _T("..")))
{
if(showDirs)
type = IMAGE_FOLDERPARENT;
} else if(wfd.dwFileAttributes & FILE_ATTRIBUTE_OFFLINE)
{
// Ignore unavailable files
continue;
} else if((wfd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
&& ((wfd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) || !showHidden))
{
// Only show hidden files if Explorer is configured to do so (and never show hidden system files)
continue;
} else if(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
// Directory
if(_tcscmp(wfd.cFileName, _T(".")) && showDirs)
type = IMAGE_FOLDER;
} else if(wfd.nFileSizeHigh > 0 || wfd.nFileSizeLow >= 9)
{
type = FilterFile(mpt::PathString::FromNative(wfd.cFileName));
if(type == FILTER_UNKNOWN_FILE)
{
// Try resolving file as link if it wasn't a module or instrument
const auto nativePath = (m_InstrLibPath.AsNative() + wfd.cFileName);
if(const auto resolvedName = linkResolver.Resolve(nativePath.c_str()); !resolvedName.empty())
{
if(resolvedName.IsDirectory() && showDirs)
type = IMAGE_FOLDER;
else if(resolvedName.IsFile())
type = FilterFile(resolvedName);
}
}
}
if(type >= FILTER_FIRST_VALID)
{
auto item = InsertInsLibItem(wfd.cFileName, type, selectedItem);
// Apparently TVIS_CUT cannot be set during insertion
if(wfd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
SetItemState(item, TVIS_CUT, TVIS_CUT);
}
} while(FindNextFile(hFind, &wfd));
FindClose(hFind);
}
}
// Sort items
TVSORTCB tvs;
tvs.hParent = (!IsSampleBrowser()) ? m_hInsLib : TVI_ROOT;
tvs.lpfnCompare = ModTreeInsLibCompareNamesProc;
tvs.lParam = (LPARAM)this;
SortChildrenCB(&tvs);
SetRedraw(TRUE);
{
mpt::lock_guard<mpt::mutex> l(m_WatchDirMutex);
if(m_InstrLibPath != m_WatchDir)
{
m_WatchDir = m_InstrLibPath;
SetEvent(m_hSwitchWatchDir);
}
}
}
// Monitor changes in the instrument library folder.
void CModTree::MonitorInstrumentLibrary()
{
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_LOWEST);
mpt::log::Trace::SetThreadId(mpt::log::Trace::ThreadKindWatchdir, GetCurrentThreadId());
DWORD result;
mpt::PathString lastWatchDir;
HANDLE hWatchDir = INVALID_HANDLE_VALUE;
DWORD64 lastRefresh = Util::GetTickCount64();
DWORD timeout = INFINITE;
DWORD interval = TrackerSettings::Instance().FSUpdateInterval;
do
{
{
mpt::lock_guard<mpt::mutex> l(m_WatchDirMutex);
if(m_WatchDir != lastWatchDir)
{
if(hWatchDir != INVALID_HANDLE_VALUE)
{
FindCloseChangeNotification(hWatchDir);
hWatchDir = INVALID_HANDLE_VALUE;
lastWatchDir = mpt::PathString();
}
if(!m_WatchDir.empty())
{
hWatchDir = FindFirstChangeNotification(m_WatchDir.AsNative().c_str(), FALSE, FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME);
lastWatchDir = m_WatchDir;
}
}
}
const HANDLE waitHandles[3] = {m_hWatchDirKillThread, m_hSwitchWatchDir, hWatchDir};
result = WaitForMultipleObjects(hWatchDir != INVALID_HANDLE_VALUE ? 3 : 2, waitHandles, FALSE, timeout);
DWORD64 now = Util::GetTickCount64();
if(result == WAIT_TIMEOUT)
{
PostMessage(WM_COMMAND, ID_MODTREE_REFRESHINSTRLIB);
lastRefresh = now;
timeout = INFINITE;
} else if(result == WAIT_OBJECT_0 + 1)
{
// nothing
// will switch to new dir in next loop iteration
} else if(result == WAIT_OBJECT_0 + 2)
{
FindNextChangeNotification(hWatchDir);
timeout = 0; // update timeout later
}
if(timeout != INFINITE)
{
// Update timeout. Can happen either because we just got a change event,
// or because we got a directory switch event and still have a change
// notification pending.
if(now - lastRefresh >= interval)
{
PostMessage(WM_COMMAND, ID_MODTREE_REFRESHINSTRLIB);
lastRefresh = now;
timeout = INFINITE;
} else
{
timeout = interval - static_cast<DWORD>(now - lastRefresh);
}
}
} while(result != WAIT_OBJECT_0);
if(hWatchDir != INVALID_HANDLE_VALUE)
{
FindCloseChangeNotification(hWatchDir);
hWatchDir = INVALID_HANDLE_VALUE;
lastWatchDir = mpt::PathString();
}
}
// Insert sample browser item.
HTREEITEM CModTree::InsertInsLibItem(const TCHAR *name, int image, const TCHAR *selectIfMatch)
{
HTREEITEM item = InsertItem(TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT,
name,
image, image,
0, 0,
0,
(!IsSampleBrowser()) ? m_hInsLib : TVI_ROOT,
TVI_LAST);
SetItemData(item, reinterpret_cast<DWORD_PTR>(item)); // Used by ModTreeInsLibCompareNamesProc
if(selectIfMatch != nullptr && !_tcscmp(name, selectIfMatch))
{
SelectItem(item);
EnsureVisible(item);
}
return item;
}
int CModTree::ModTreeInsLibCompareNamesGetItem(HTREEITEM item, CString &resultStr)
{
TVITEM tvi;
tvi.mask = TVIF_TEXT | TVIF_IMAGE;
tvi.hItem = item;
int len = std::max(64, resultStr.GetAllocLength());
while(true)
{
tvi.pszText = resultStr.GetBuffer(len);
tvi.cchTextMax = len + 1;
if(!GetItem(&tvi))
return int16_max;
if(int resultLen = static_cast<int>(_tcsnlen(tvi.pszText, len)); resultLen < len)
{
resultStr.ReleaseBuffer(resultLen);
// Item image indicates sort order
switch(tvi.iImage)
{
case IMAGE_FOLDERPARENT:
return 1;
case IMAGE_FOLDER:
return 2;
case IMAGE_FOLDERSONG:
return 3;
case IMAGE_SAMPLES:
case IMAGE_OPLINSTR:
// Only group instruments and samples separately if we're browsing inside a module file
if(!m_SongFileName.empty())
return 5;
[[fallthrough]];
case IMAGE_INSTRUMENTS:
default:
return 4;
}
}
len *= 2;
}
}
int CALLBACK CModTree::ModTreeInsLibCompareNamesProc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
{
auto that = reinterpret_cast<CModTree *>(lParamSort);
const auto itemL = reinterpret_cast<HTREEITEM>(lParam1), itemR = reinterpret_cast<HTREEITEM>(lParam2);
if(itemL == that->m_hInsLib)
return -1;
else if(itemR == that->m_hInsLib)
return 1;
const int sortOrderL = that->ModTreeInsLibCompareNamesGetItem(itemL, that->m_compareStrL);
const int sortOrderR = that->ModTreeInsLibCompareNamesGetItem(itemR, that->m_compareStrR);
if(sortOrderL != sortOrderR)
return sortOrderL - sortOrderR;
return ::CompareString(LOCALE_USER_DEFAULT, that->m_stringCompareFlags,
that->m_compareStrL.GetBuffer(), -1,
that->m_compareStrR.GetBuffer(), -1) - 2;
}
int CALLBACK CModTree::ModTreeInsLibCompareProc(LPARAM lParam1, LPARAM lParam2, LPARAM)
{
lParam1 &= 0x7FFFFFFF;
lParam2 &= 0x7FFFFFFF;
return static_cast<int>(lParam1 - lParam2);
}
int CALLBACK CModTree::ModTreeDrumCompareProc(LPARAM lParam1, LPARAM lParam2, LPARAM pDLSBank)
{
lParam1 &= 0x7FFFFFFF;
lParam2 &= 0x7FFFFFFF;
// Same drum instrument?
if((lParam1 & 0xFFFF) == (lParam2 & 0xFFFF))
{
if(pDLSBank)
{
// Compare minimum key of these regions
const DLSINSTRUMENT *pDlsIns = reinterpret_cast<CDLSBank *>(pDLSBank)->GetInstrument(lParam1 & 0xFFFF);
uint16 region1 = static_cast<uint16>((lParam1 >> 16) & 0xFFFF);
uint16 region2 = static_cast<uint16>((lParam2 >> 16) & 0xFFFF);
if(pDlsIns && region1 < pDlsIns->Regions.size() && region2 < pDlsIns->Regions.size())
{
lParam1 = pDlsIns->Regions[region1].uKeyMin;
lParam2 = pDlsIns->Regions[region2].uKeyMin;
}
}
}
return static_cast<int>(lParam1 - lParam2);
}
void CModTree::SetFullInstrumentLibraryPath(mpt::PathString path)
{
if(path.IsDirectory())
{
path.EnsureTrailingSlash();
InstrumentLibraryChDir(path, false);
} else if(path.IsFile())
{
// Browse module contents
CModTree *dirBrowser = CMainFrame::GetMainFrame()->GetUpperTreeview();
dirBrowser->m_InstrLibPath = path.GetPath();
dirBrowser->RefreshInstrumentLibrary();
dirBrowser->InstrumentLibraryChDir(path.GetFullFileName(), true);
}
}
void CModTree::InstrumentLibraryChDir(mpt::PathString dir, bool isSong)
{
if(dir.empty())
return;
if(IsSampleBrowser())
{
CMainFrame::GetMainFrame()->GetUpperTreeview()->InstrumentLibraryChDir(dir, isSong);
return;
}
BeginWaitCursor();
bool ok = false;
const bool goUp = (dir == P_(".."));
m_previousPath = {};
if(isSong && !goUp)
{
ok = m_pDataTree->InsLibSetFullPath(m_InstrLibPath, dir);
if(ok)
{
m_pDataTree->RefreshInstrumentLibrary();
m_InstrLibHighlightPath = dir;
}
} else
{
if(goUp)
{
if(isSong)
{
// Leave song
m_InstrLibHighlightPath = std::move(m_pDataTree->m_SongFileName);
dir = m_InstrLibPath;
} else
{
// Go one dir up.
mpt::winstring prevDir = m_InstrLibPath.GetPath().AsNative();
mpt::winstring::size_type pos = prevDir.find_last_of(_T("\\/"), prevDir.length() - 2);
if(pos != mpt::winstring::npos)
{
m_InstrLibHighlightPath = mpt::PathString::FromNative(prevDir.substr(pos + 1, prevDir.length() - pos - 2)); // Highlight previously accessed directory
prevDir = prevDir.substr(0, pos + 1);
}
m_previousPath = m_InstrLibHighlightPath;
dir = mpt::PathString::FromNative(prevDir);
}
} else
{
// Drives are formatted like "E:\", folders are just folder name without slash.
do
{
if(!dir.HasTrailingSlash())
{
dir = m_InstrLibPath + dir;
dir.EnsureTrailingSlash();
}
m_InstrLibHighlightPath = P_(".."); // Highlight first entry
FolderScanner scan(dir, FolderScanner::kFilesAndDirectories);
mpt::PathString name;
if(scan.Next(name) && !scan.Next(name) && name.IsDirectory())
{
// There is only one directory and nothing else in the path,
// so skip this directory and automatically descend further down into the tree.
dir = name;
dir.EnsureTrailingSlash();
continue;
}
} while(false);
}
if(dir.IsDirectory())
{
m_SongFileName = P_("");
delete m_SongFile;
m_SongFile = nullptr;
m_InstrLibPath = dir;
GetSampleBrowser()->m_InstrLibHighlightPath = m_InstrLibHighlightPath;
PostMessage(WM_COMMAND, ID_MODTREE_REFRESHINSTRLIB);
ok = true;
}
}
EndWaitCursor();
if(ok)
{
mpt::lock_guard<mpt::mutex> l(m_WatchDirMutex);
m_WatchDir = mpt::PathString();
} else
{
Reporting::Error(MPT_CFORMAT("Unable to browse to \"{}\"")(dir), _T("Instrument Library"));
}
}
bool CModTree::GetDropInfo(DRAGONDROP &dropInfo, mpt::PathString &fullPath)
{
const auto dragDoc = m_docInfo.find(m_dragDoc);
dropInfo.sndFile = dragDoc != m_docInfo.end() ? &dragDoc->second.modDoc.GetSoundFile() : nullptr;
dropInfo.dropType = DRAGONDROP_NOTHING;
dropInfo.dropItem = m_itemDrag.val1;
dropInfo.dropParam = 0;
switch(m_itemDrag.type)
{
case MODITEM_ORDER:
dropInfo.dropType = DRAGONDROP_ORDER;
break;
case MODITEM_PATTERN:
dropInfo.dropType = DRAGONDROP_PATTERN;
break;
case MODITEM_SAMPLE:
dropInfo.dropType = DRAGONDROP_SAMPLE;
break;
case MODITEM_INSTRUMENT:
dropInfo.dropType = DRAGONDROP_INSTRUMENT;
break;
case MODITEM_SEQUENCE:
case MODITEM_HDR_ORDERS:
dropInfo.dropType = DRAGONDROP_SEQUENCE;
break;
case MODITEM_INSLIB_SAMPLE:
case MODITEM_INSLIB_INSTRUMENT:
if(!m_SongFileName.empty())
{
const uint32 n = ConvertStrTo<uint32>(GetItemText(m_hItemDrag));
dropInfo.dropType = (m_itemDrag.type == MODITEM_INSLIB_SAMPLE) ? DRAGONDROP_SAMPLE : DRAGONDROP_INSTRUMENT;
dropInfo.dropItem = n;
dropInfo.sndFile = m_SongFile;
dropInfo.dropParam = 0;
} else
{
fullPath = InsLibGetFullPath(m_hItemDrag);
dropInfo.dropType = DRAGONDROP_SOUNDFILE;
dropInfo.dropParam = reinterpret_cast<uintptr_t>(&fullPath);
}
break;
case MODITEM_MIDIPERCUSSION:
dropInfo.dropItem |= 0x80;
[[fallthrough]];
case MODITEM_MIDIINSTRUMENT:
{
MidiLibrary &midiLib = CTrackApp::GetMidiLibrary();
if(!midiLib[dropInfo.dropItem & 0xFF].empty())
{
fullPath = midiLib[dropInfo.dropItem & 0xFF];
dropInfo.dropType = DRAGONDROP_MIDIINSTR;
dropInfo.dropParam = reinterpret_cast<uintptr_t>(&fullPath);
}
}
break;
case MODITEM_INSLIB_SONG:
fullPath = InsLibGetFullPath(m_hItemDrag);
dropInfo.sndFile = nullptr;
dropInfo.dropType = DRAGONDROP_SONG;
dropInfo.dropItem = 0;
dropInfo.dropParam = reinterpret_cast<uintptr_t>(&fullPath);
break;
case MODITEM_DLSBANK_INSTRUMENT:
{
dropInfo.dropType = DRAGONDROP_DLS;
dropInfo.dropItem = static_cast<uint32>(GetDLSBankIndexFromItem(m_hItemDrag)); // bank #
// Melodic: (Instrument)
// Drums: (0x80000000) | (Region << 16) | (Instrument)
dropInfo.dropParam = m_itemDrag.val1;
}
break;
}
return (dropInfo.dropType != DRAGONDROP_NOTHING);
}
bool CModTree::CanDrop(HTREEITEM hItem, bool doDrop)
{
const ModItem modItemDrop = GetModItem(hItem);
const uint32 modItemDropID = modItemDrop.val1;
const uint32 modItemDragID = m_itemDrag.val1;
const auto dragIter = m_docInfo.find(m_dragDoc);
const auto selIter = m_docInfo.find(m_selectedDoc);
const ModTreeDocInfo *infoDrag = dragIter != m_docInfo.end() ? &dragIter->second : nullptr;
const ModTreeDocInfo *infoDrop = selIter != m_docInfo.end() ? &selIter->second : nullptr;
CModDoc *modDoc = infoDrop ? &infoDrop->modDoc : nullptr;
CSoundFile *sndFile = modDoc ? &modDoc->GetSoundFile() : nullptr;
const bool sameModDoc = infoDrag && (modDoc == &infoDrag->modDoc);
const bool sameItem = modItemDrop == m_itemDrag && sameModDoc;
switch(modItemDrop.type)
{
case MODITEM_ORDER:
case MODITEM_SEQUENCE:
if(m_itemDrag.type == MODITEM_ORDER && modDoc && sameModDoc)
{
// Drop an order somewhere
if(doDrop)
{
SEQUENCEINDEX seqFrom = static_cast<SEQUENCEINDEX>(m_itemDrag.val2), seqTo = static_cast<SEQUENCEINDEX>(modItemDrop.val2);
ORDERINDEX ordFrom = static_cast<ORDERINDEX>(m_itemDrag.val1), ordTo = static_cast<ORDERINDEX>(modItemDrop.val1);
if(modItemDrop.type == MODITEM_SEQUENCE)
{
// Drop on sequence -> attach
seqTo = static_cast<SEQUENCEINDEX>(modItemDrop.val1);
ordTo = sndFile->Order(seqTo).GetLengthTailTrimmed();
}
if(seqFrom != seqTo || ordFrom != ordTo)
{
if(modDoc->MoveOrder(ordFrom, ordTo, true, false, seqFrom, seqTo) == true)
{
modDoc->SetModified();
}
}
}
return true;
} else if(modItemDrop.type == MODITEM_SEQUENCE && m_itemDrag.type == MODITEM_SEQUENCE && modDoc && sameModDoc)
{
if(doDrop && !sameItem)
{
// Rearrange sequences
const SEQUENCEINDEX from = static_cast<SEQUENCEINDEX>(modItemDragID), to = static_cast<SEQUENCEINDEX>(modItemDropID);
std::vector<SEQUENCEINDEX> newOrder(sndFile->Order.GetNumSequences());
std::iota(newOrder.begin(), newOrder.end(), SEQUENCEINDEX(0));
newOrder.erase(newOrder.begin() + from);
newOrder.insert(newOrder.begin() + to, from);
modDoc->ReArrangeSequences(newOrder);
auto curSeq = sndFile->Order.GetCurrentSequenceIndex();
if(curSeq == from)
curSeq = to;
else if(from > curSeq && to <= curSeq)
curSeq++;
else if(from < curSeq && to >= curSeq)
curSeq--;
sndFile->Order.SetSequence(curSeq);
modDoc->UpdateAllViews(nullptr, SequenceHint(SEQUENCEINDEX_INVALID).Names().Data());
modDoc->SetModified();
SelectItem(hItem);
}
return true;
}
break;
case MODITEM_HDR_ORDERS:
// Drop your sequences here.
// At the moment, only dropping sequences into another module is possible and it doesn't copy the patterns themselves.
if((m_itemDrag.type == MODITEM_SEQUENCE || m_itemDrag.type == MODITEM_HDR_ORDERS) && modDoc && sndFile && infoDrag && !sameModDoc)
{
if(doDrop && infoDrag != nullptr)
{
// copy mod sequence over.
CSoundFile &dragSndFile = infoDrag->modDoc.GetSoundFile();
const SEQUENCEINDEX origSeqId = static_cast<SEQUENCEINDEX>(modItemDragID);
const ModSequence &origSeq = dragSndFile.Order(origSeqId);
SEQUENCEINDEX sequenceHint = SEQUENCEINDEX_INVALID;
if(sndFile->GetModSpecifications().sequencesMax > 1)
{
sequenceHint = sndFile->Order.AddSequence();
} else
{
if(Reporting::Confirm(_T("Replace the current orderlist?"), _T("Sequence import")) == cnfNo)
return false;
sequenceHint = 0;
}
sndFile->Order().resize(std::min(sndFile->GetModSpecifications().ordersMax, origSeq.GetLength()), sndFile->Order.GetInvalidPatIndex());
for(ORDERINDEX nOrd = 0; nOrd < std::min(sndFile->GetModSpecifications().ordersMax, origSeq.GetLengthTailTrimmed()); nOrd++)
{
PATTERNINDEX pat = dragSndFile.Order(origSeqId)[nOrd];
// translate pattern index
if(pat == dragSndFile.Order.GetInvalidPatIndex())
pat = sndFile->Order.GetInvalidPatIndex();
else if(pat == dragSndFile.Order.GetIgnoreIndex() && sndFile->GetModSpecifications().hasIgnoreIndex)
pat = sndFile->Order.GetIgnoreIndex();
else if(pat == dragSndFile.Order.GetIgnoreIndex() && !sndFile->GetModSpecifications().hasIgnoreIndex)
pat = sndFile->Order.GetInvalidPatIndex();
else if(pat >= sndFile->GetModSpecifications().patternsMax)
pat = sndFile->Order.GetInvalidPatIndex();
sndFile->Order()[nOrd] = pat;
}
modDoc->UpdateAllViews(nullptr, SequenceHint(sequenceHint).Data());
modDoc->SetModified();
}
return true;
}
break;
case MODITEM_SAMPLE:
if(m_itemDrag.type == MODITEM_SAMPLE && modDoc && infoDrag != nullptr)
{
if(doDrop)
{
if(sameModDoc)
{
// Reorder samples in a module
if(sameItem)
return true;
const SAMPLEINDEX from = static_cast<SAMPLEINDEX>(modItemDragID - 1), to = static_cast<SAMPLEINDEX>(modItemDropID - 1);
std::vector<SAMPLEINDEX> newOrder(modDoc->GetNumSamples());
std::iota(newOrder.begin(), newOrder.end(), SAMPLEINDEX(1));
newOrder.erase(newOrder.begin() + from);
newOrder.insert(newOrder.begin() + to, from + 1);
modDoc->ReArrangeSamples(newOrder);
} else
{
// Load sample into other module
sndFile->ReadSampleFromSong(static_cast<SAMPLEINDEX>(modItemDropID), infoDrag->modDoc.GetSoundFile(), static_cast<SAMPLEINDEX>(modItemDragID));
}
modDoc->UpdateAllViews(nullptr, SampleHint().Info().Data().Names());
modDoc->UpdateAllViews(nullptr, PatternHint().Data());
modDoc->UpdateAllViews(nullptr, InstrumentHint().Info());
modDoc->SetModified();
SelectItem(hItem);
}
return true;
}
break;
case MODITEM_INSTRUMENT:
if(m_itemDrag.type == MODITEM_INSTRUMENT && modDoc && infoDrag != nullptr)
{
if(doDrop)
{
if(sameModDoc)
{
// Reorder instruments in a module
if(sameItem)
return true;
const INSTRUMENTINDEX from = static_cast<INSTRUMENTINDEX>(modItemDragID - 1), to = static_cast<INSTRUMENTINDEX>(modItemDropID - 1);
std::vector<INSTRUMENTINDEX> newOrder(modDoc->GetNumInstruments());
std::iota(newOrder.begin(), newOrder.end(), INSTRUMENTINDEX(1));
newOrder.erase(newOrder.begin() + from);
newOrder.insert(newOrder.begin() + to, from + 1);
modDoc->ReArrangeInstruments(newOrder);
} else
{
// Load instrument into other module
sndFile->ReadInstrumentFromSong(static_cast<INSTRUMENTINDEX>(modItemDropID), infoDrag->modDoc.GetSoundFile(), static_cast<INSTRUMENTINDEX>(modItemDragID));
}
modDoc->UpdateAllViews(nullptr, InstrumentHint().Info().Envelope().Names());
modDoc->UpdateAllViews(nullptr, PatternHint().Data());
modDoc->SetModified();
SelectItem(hItem);
}
return true;
}
break;
case MODITEM_MIDIINSTRUMENT:
case MODITEM_MIDIPERCUSSION:
if((m_itemDrag.type == MODITEM_INSLIB_SAMPLE) || (m_itemDrag.type == MODITEM_INSLIB_INSTRUMENT))
{
if(doDrop)
{
mpt::PathString fullPath = InsLibGetFullPath(m_hItemDrag);
if(modItemDrop.type == MODITEM_MIDIINSTRUMENT)
SetMidiInstrument(modItemDropID, fullPath);
else
SetMidiPercussion(modItemDropID, fullPath);
}
return true;
}
break;
}
return false;
}
void CModTree::UpdatePlayPos(CModDoc &modDoc, Notification *pNotify)
{
ModTreeDocInfo *info = GetDocumentInfoFromModDoc(modDoc);
if(info == nullptr)
return;
const CSoundFile &sndFile = modDoc.GetSoundFile();
ORDERINDEX nNewOrd = (pNotify) ? pNotify->order : ORDERINDEX_INVALID;
SEQUENCEINDEX nNewSeq = sndFile.Order.GetCurrentSequenceIndex();
if(nNewOrd != info->ordSel || nNewSeq != info->seqSel)
{
// Remove bold state from old item
if(info->seqSel < info->tiOrders.size() && info->ordSel < info->tiOrders[info->seqSel].size())
SetItemState(info->tiOrders[info->seqSel][info->ordSel], 0, TVIS_BOLD);
info->ordSel = nNewOrd;
info->seqSel = nNewSeq;
if(info->seqSel < info->tiOrders.size() && info->ordSel < info->tiOrders[info->seqSel].size())
SetItemState(info->tiOrders[info->seqSel][info->ordSel], TVIS_BOLD, TVIS_BOLD);
else
UpdateView(*info, SequenceHint().Data());
}
// Update sample / instrument playing status icons (will only detect instruments with samples, though)
if((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_LIVEUPDATETREE) == 0)
return;
// TODO: Is there a way to find out if the treeview is actually visible?
/*static int nUpdateCount = 0;
nUpdateCount++;
if(nUpdateCount < 5) return; // don't update too often
nUpdateCount = 0;*/
// check whether the lists are actually visible (don't waste resources)
const bool updateSamples = IsItemExpanded(info->hSamples), updateInstruments = IsItemExpanded(info->hInstruments);
info->samplesPlaying.reset();
info->instrumentsPlaying.reset();
if(!updateSamples && !updateInstruments)
return;
for(const auto &chn : sndFile.m_PlayState.Chn)
{
if(chn.pCurrentSample != nullptr && chn.nLength != 0 && chn.IsSamplePlaying())
{
if(updateSamples)
{
for(SAMPLEINDEX nSmp = sndFile.GetNumSamples(); nSmp >= 1; nSmp--)
{
if(chn.pModSample == &sndFile.GetSample(nSmp))
{
info->samplesPlaying.set(nSmp);
break;
}
}
}
if(updateInstruments)
{
for(INSTRUMENTINDEX nIns = sndFile.GetNumInstruments(); nIns >= 1; nIns--)
{
if(chn.pModInstrument == sndFile.Instruments[nIns])
{
info->instrumentsPlaying.set(nIns);
break;
}
}
}
}
}
// what should be updated?
if(updateSamples)
UpdateView(*info, SampleHint().Info());
if(updateInstruments)
UpdateView(*info, InstrumentHint().Info());
}
/////////////////////////////////////////////////////////////////////////////
// CViewModTree message handlers
void CModTree::OnUpdate(CModDoc *pModDoc, UpdateHint hint, CObject *pHint)
{
if(pHint == this)
return;
for(auto &[doc, docInfo] : m_docInfo)
{
if(doc == pModDoc || !pModDoc)
{
UpdateView(docInfo, hint);
if(pModDoc)
break;
}
}
}
void CModTree::OnItemExpanded(LPNMHDR pnmhdr, LRESULT *pResult)
{
LPNMTREEVIEW pnm = (LPNMTREEVIEW)pnmhdr;
if((pnm->itemNew.iImage == IMAGE_FOLDER) || (pnm->itemNew.iImage == IMAGE_OPENFOLDER))
{
int iNewImage = (pnm->itemNew.state & TVIS_EXPANDED) ? IMAGE_OPENFOLDER : IMAGE_FOLDER;
SetItemImage(pnm->itemNew.hItem, iNewImage, iNewImage);
}
if(pResult)
*pResult = TRUE;
}
void CModTree::OnBeginDrag(HTREEITEM hItem, bool bLeft, LRESULT *pResult)
{
if(!(m_dwStatus & TREESTATUS_DRAGGING))
{
bool bDrag = false;
m_hDropWnd = NULL;
m_hItemDrag = hItem;
if(m_hItemDrag != NULL)
{
if(!ItemHasChildren(m_hItemDrag))
SelectItem(m_hItemDrag);
}
m_itemDrag = GetModItem(m_hItemDrag);
m_dragDoc = m_selectedDoc;
switch(m_itemDrag.type)
{
case MODITEM_ORDER:
case MODITEM_PATTERN:
case MODITEM_SAMPLE:
case MODITEM_INSTRUMENT:
case MODITEM_SEQUENCE:
case MODITEM_MIDIINSTRUMENT:
case MODITEM_MIDIPERCUSSION:
case MODITEM_INSLIB_SAMPLE:
case MODITEM_INSLIB_INSTRUMENT:
case MODITEM_INSLIB_SONG:
bDrag = true;
break;
case MODITEM_HDR_ORDERS:
// can we drag an order header? (only in MPTM format and if there's only one sequence)
{
const CModDoc *pModDoc = m_docInfo.count(m_dragDoc) ? m_dragDoc : nullptr;
if(pModDoc && pModDoc->GetSoundFile().Order.GetNumSequences() == 1)
bDrag = true;
}
break;
default:
if(m_itemDrag.type == MODITEM_DLSBANK_INSTRUMENT)
bDrag = true;
}
if(bDrag)
{
m_dwStatus |= (bLeft) ? TREESTATUS_LDRAG : TREESTATUS_RDRAG;
m_hItemDrop = NULL;
SetCapture();
}
}
if(pResult)
*pResult = TRUE;
}
void CModTree::OnBeginRDrag(LPNMHDR pnmhdr, LRESULT *pResult)
{
if(pnmhdr)
{
LPNMTREEVIEW pnmtv = (LPNMTREEVIEW)pnmhdr;
OnBeginDrag(pnmtv->itemNew.hItem, false, pResult);
}
}
void CModTree::OnBeginLDrag(LPNMHDR pnmhdr, LRESULT *pResult)
{
if(pnmhdr)
{
LPNMTREEVIEW pnmtv = (LPNMTREEVIEW)pnmhdr;
OnBeginDrag(pnmtv->itemNew.hItem, true, pResult);
}
}
void CModTree::OnItemDblClk(LPNMHDR, LRESULT *pResult)
{
POINT pt;
GetCursorPos(&pt);
ScreenToClient(&pt);
HTREEITEM hItem = GetSelectedItem();
if((hItem) && (hItem == HitTest(pt)))
{
ExecuteItem(hItem);
}
if(pResult)
*pResult = 0;
}
void CModTree::OnItemReturn(LPNMHDR, LRESULT *pResult)
{
HTREEITEM hItem = GetSelectedItem();
if(hItem)
ExecuteItem(hItem);
if(pResult)
*pResult = 0;
}
void CModTree::OnItemRightClick(LPNMHDR, LRESULT *pResult)
{
CPoint pt, ptClient;
UINT flags = 0;
GetCursorPos(&pt);
ptClient = pt;
ScreenToClient(&ptClient);
OnItemRightClick(HitTest(ptClient, &flags), pt);
if(pResult)
*pResult = 0;
}
void CModTree::OnItemRightClick(HTREEITEM hItem, CPoint pt)
{
HMENU hMenu;
if(m_dwStatus & TREESTATUS_LDRAG)
{
if(ItemHasChildren(hItem))
{
Expand(hItem, TVE_TOGGLE);
} else
{
m_hItemDrop = NULL;
m_hDropWnd = NULL;
OnEndDrag(TREESTATUS_DRAGGING);
}
} else
{
if(m_dwStatus & TREESTATUS_DRAGGING)
{
m_hItemDrop = NULL;
m_hDropWnd = NULL;
OnEndDrag(TREESTATUS_DRAGGING);
}
hMenu = ::CreatePopupMenu();
if(hMenu)
{
const CModDoc *modDoc = GetDocumentFromItem(hItem);
const CSoundFile *sndFile = modDoc != nullptr ? &modDoc->GetSoundFile() : nullptr;
UINT nDefault = 0;
BOOL bSep = FALSE;
const ModItem modItem = GetModItem(hItem);
const uint32 modItemID = modItem.val1;
SelectItem(hItem);
switch(modItem.type)
{
case MODITEM_HDR_SONG:
nDefault = ID_MODTREE_EXECUTE;
AppendMenu(hMenu, MF_STRING, nDefault, _T("&View"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_CLOSE, _T("&Close"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_RENAME, _T("Re&name"));
break;
case MODITEM_COMMENTS:
nDefault = ID_MODTREE_EXECUTE;
AppendMenu(hMenu, MF_STRING, nDefault, _T("&View Comments"));
break;
case MODITEM_ORDER:
case MODITEM_PATTERN:
nDefault = ID_MODTREE_EXECUTE;
AppendMenu(hMenu, MF_STRING, nDefault, _T("&Edit Pattern"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_REMOVE,
(modItem.type == MODITEM_ORDER) ? _T("&Delete from list") : _T("&Delete Pattern"));
if(modItem.type == MODITEM_PATTERN && sndFile && sndFile->GetModSpecifications().hasPatternNames)
AppendMenu(hMenu, MF_STRING, ID_MODTREE_RENAME, _T("Re&name Pattern"));
else if(modItem.type == MODITEM_ORDER)
AppendMenu(hMenu, MF_STRING, ID_MODTREE_RENAME, _T("&Set Pattern"));
break;
case MODITEM_SEQUENCE:
if(sndFile)
{
bool isCurSeq = false;
if(sndFile->GetModSpecifications().sequencesMax > 1)
{
if(sndFile->Order((SEQUENCEINDEX)modItemID).GetLength() == 0)
{
nDefault = ID_MODTREE_SWITCHTO;
}
isCurSeq = (sndFile->Order.GetCurrentSequenceIndex() == (SEQUENCEINDEX)modItemID);
}
if(!isCurSeq)
{
AppendMenu(hMenu, MF_STRING, ID_MODTREE_SWITCHTO, _T("&Switch to Seqeuence"));
}
AppendMenu(hMenu, MF_STRING | (sndFile->Order.GetNumSequences() < MAX_SEQUENCES ? 0 : MF_GRAYED), ID_MODTREE_INSERT, _T("&Insert Sequence"));
AppendMenu(hMenu, MF_STRING | (sndFile->Order.GetNumSequences() < MAX_SEQUENCES ? 0 : MF_GRAYED), ID_MODTREE_DUPLICATE , _T("D&uplicate Sequence"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_REMOVE, _T("&Delete Sequence"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_RENAME, _T("Re&name Sequence"));
}
break;
case MODITEM_HDR_ORDERS:
if(sndFile && sndFile->GetModSpecifications().sequencesMax > 1)
{
AppendMenu(hMenu, MF_STRING, ID_MODTREE_INSERT, _T("&Insert Sequence"));
if(sndFile->Order.GetNumSequences() == 1)
{
// This is a sequence
AppendMenu(hMenu, MF_STRING, ID_MODTREE_DUPLICATE, _T("D&uplicate Sequence"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_RENAME, _T("Re&name Sequence"));
}
}
break;
case MODITEM_SAMPLE:
{
nDefault = ID_MODTREE_EXECUTE;
AppendMenu(hMenu, MF_STRING, nDefault, _T("&View Sample"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_PLAY, _T("&Play Sample"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_INSERT, _T("&Insert Sample"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_DUPLICATE, _T("D&uplicate Sample"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_REMOVE, _T("&Delete Sample"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_RENAME, _T("Re&name Sample"));
if ((modDoc) && (!modDoc->GetNumInstruments()))
{
AppendMenu(hMenu, MF_SEPARATOR, NULL, _T(""));
AppendMenu(hMenu, (modDoc->IsSampleMuted((SAMPLEINDEX)modItemID) ? MF_CHECKED : 0) | MF_STRING, ID_MODTREE_MUTE, _T("&Mute Sample"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_SOLO, _T("S&olo Sample"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_UNMUTEALL, _T("&Unmute all"));
}
if(sndFile != nullptr)
{
SAMPLEINDEX smpID = static_cast<SAMPLEINDEX>(modItem.val1);
const ModSample &sample = sndFile->GetSample(smpID);
const bool hasPath = sndFile->SampleHasPath(smpID);
const bool menuForThisSample = (sample.HasSampleData() && sndFile->GetType() == MOD_TYPE_MPT) || hasPath;
bool anyPath = false, anyModified = false, anyMissing = false;
for(SAMPLEINDEX smp = 1; smp <= sndFile->GetNumSamples(); smp++)
{
if(sndFile->SampleHasPath(smp) && smp != smpID)
{
anyPath = true;
if(sndFile->GetSample(smp).HasSampleData() && sndFile->GetSample(smp).uFlags[SMP_MODIFIED])
{
anyModified = true;
}
}
if(sndFile->IsExternalSampleMissing(smp))
{
anyMissing = true;
}
if(anyPath && anyModified && anyMissing) break;
}
if(menuForThisSample || anyPath || anyModified)
{
AppendMenu(hMenu, MF_SEPARATOR, NULL, _T(""));
if(menuForThisSample) AppendMenu(hMenu, MF_STRING | ((sndFile->GetType() == MOD_TYPE_MPT || hasPath) ? 0 : MF_GRAYED), ID_MODTREE_SETPATH, _T("Set P&ath"));
if(menuForThisSample) AppendMenu(hMenu, MF_STRING | ((hasPath && sample.HasSampleData() && sample.uFlags[SMP_MODIFIED]) ? 0 : MF_GRAYED), ID_MODTREE_SAVEITEM, _T("&Save"));
if(anyModified) AppendMenu(hMenu, MF_STRING, ID_MODTREE_SAVEALL, _T("&Save All"));
if(menuForThisSample) AppendMenu(hMenu, MF_STRING | (hasPath ? 0 : MF_GRAYED), ID_MODTREE_RELOADITEM, _T("&Reload"));
if(anyPath) AppendMenu(hMenu, MF_STRING, ID_MODTREE_RELOADALL, _T("&Reload All"));
if(anyMissing) AppendMenu(hMenu, MF_STRING, ID_MODTREE_FINDMISSING, _T("&Find Missing Samples"));
}
}
}
break;
case MODITEM_INSTRUMENT:
{
nDefault = ID_MODTREE_EXECUTE;
AppendMenu(hMenu, MF_STRING, nDefault, _T("&View Instrument"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_PLAY, _T("&Play Instrument"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_INSERT, _T("&Insert Instrument"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_DUPLICATE, _T("D&uplicate Instrument"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_REMOVE, _T("&Delete Instrument"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_RENAME, _T("Re&name Instrument"));
if (modDoc)
{
AppendMenu(hMenu, MF_SEPARATOR, NULL, _T(""));
AppendMenu(hMenu, (modDoc->IsInstrumentMuted((INSTRUMENTINDEX)modItemID) ? MF_CHECKED : 0) | MF_STRING, ID_MODTREE_MUTE, _T("&Mute Instrument"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_SOLO, _T("S&olo Instrument"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_UNMUTEALL, _T("&Unmute all"));
}
}
break;
case MODITEM_HDR_EFFECTS:
if(sndFile && sndFile->m_loadedPlugins)
{
AppendMenu(hMenu, MF_STRING | (AllPluginsBypassed(*sndFile, false) ? MF_CHECKED : 0), ID_MODTREE_MUTE, _T("B&ypass All Plugins"));
if(HasEffectPlugins(*sndFile))
AppendMenu(hMenu, MF_STRING | (AllPluginsBypassed(*sndFile, true) ? MF_CHECKED : 0), ID_MODTREE_MUTE_ONLY_EFFECTS, _T("Bypass All &Effects"));
}
break;
case MODITEM_EFFECT:
{
nDefault = ID_MODTREE_EXECUTE;
AppendMenu(hMenu, MF_STRING, nDefault, _T("&Edit"));
if(modDoc != nullptr)
{
AppendMenu(hMenu, (modDoc->GetSoundFile().m_MixPlugins[modItemID].IsBypassed() ? MF_CHECKED : 0) | MF_STRING, ID_MODTREE_MUTE, _T("&Bypass"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_REMOVE, _T("&Delete Plugin"));
}
}
break;
case MODITEM_MIDIINSTRUMENT:
case MODITEM_MIDIPERCUSSION:
nDefault = ID_MODTREE_EXECUTE;
AppendMenu(hMenu, MF_STRING, nDefault, _T("&Map Instrument"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_PLAY, _T("&Play Instrument"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_REMOVE, _T("&Unmap Instrument"));
AppendMenu(hMenu, MF_SEPARATOR, NULL, _T(""));
[[fallthrough]];
case MODITEM_HDR_MIDILIB:
case MODITEM_HDR_MIDIGROUP:
AppendMenu(hMenu, MF_STRING, ID_IMPORT_MIDILIB, _T("&Import MIDI Library"));
AppendMenu(hMenu, MF_STRING, ID_EXPORT_MIDILIB, _T("E&xport MIDI Library"));
bSep = TRUE;
break;
case MODITEM_HDR_INSTRUMENTLIB:
if(!IsSampleBrowser())
break;
if(!m_SongFileName.empty())
AppendMenu(hMenu, MF_STRING, ID_MODTREE_CLOSE, _T("&Close Song"));
[[fallthrough]];
case MODITEM_INSLIB_FOLDER:
nDefault = ID_MODTREE_EXECUTE;
AppendMenu(hMenu, MF_STRING, nDefault, _T("&Browse..."));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_RENAME, _T("Set &Path"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_OPENITEM, _T("&Open in Explorer"));
{
auto insDir = TrackerSettings::Instance().PathInstruments.GetDefaultDir();
auto smpDir = TrackerSettings::Instance().PathSamples.GetDefaultDir();
if(!insDir.empty() && insDir != m_InstrLibPath)
AppendMenu(hMenu, MF_STRING, ID_MODTREE_GOTO_INSDIR, _T("Go to &Instrument directory"));
if(!smpDir.empty() && smpDir != insDir && smpDir != m_InstrLibPath)
AppendMenu(hMenu, MF_STRING, ID_MODTREE_GOTO_SMPDIR, _T("Go to Sa&mple directory"));
}
break;
case MODITEM_INSLIB_SONG:
nDefault = ID_MODTREE_EXECUTE;
AppendMenu(hMenu, MF_STRING, nDefault, _T("&Browse Song..."));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_OPENITEM, _T("&Edit Song"));
AppendMenu(hMenu, MF_SEPARATOR, NULL, _T(""));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_REMOVE, _T("&Delete"));
break;
case MODITEM_INSLIB_SAMPLE:
case MODITEM_INSLIB_INSTRUMENT:
nDefault = ID_MODTREE_PLAY;
if(!m_SongFileName.empty())
{
AppendMenu(hMenu, MF_STRING, ID_MODTREE_PLAY, _T("&Play"));
} else
{
AppendMenu(hMenu, MF_STRING, ID_MODTREE_PLAY, _T("&Play File"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_REMOVE, _T("&Delete"));
}
break;
case MODITEM_DLSBANK_FOLDER:
nDefault = ID_SOUNDBANK_PROPERTIES;
AppendMenu(hMenu, MF_STRING, nDefault, _T("&Properties"));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_REMOVE, _T("Re&move this bank"));
[[fallthrough]];
case MODITEM_NULL:
AppendMenu(hMenu, MF_STRING, ID_ADD_SOUNDBANK, _T("Add Sound &Bank..."));
bSep = TRUE;
break;
case MODITEM_DLSBANK_INSTRUMENT:
nDefault = ID_MODTREE_PLAY;
AppendMenu(hMenu, MF_STRING, ID_MODTREE_PLAY, _T("&Play Instrument"));
break;
}
if (nDefault) SetMenuDefaultItem(hMenu, nDefault, FALSE);
if ((modItem.type == MODITEM_INSLIB_FOLDER)
|| (modItem.type == MODITEM_INSLIB_SONG)
|| (modItem.type == MODITEM_HDR_INSTRUMENTLIB))
{
if ((bSep) || (nDefault)) AppendMenu(hMenu, MF_SEPARATOR, NULL, _T(""));
AppendMenu(hMenu, TrackerSettings::Instance().showDirsInSampleBrowser ? (MF_STRING|MF_CHECKED) : MF_STRING, ID_MODTREE_SHOWDIRS, _T("Show &Directories in Sample Browser"));
AppendMenu(hMenu, (m_showAllFiles) ? (MF_STRING|MF_CHECKED) : MF_STRING, ID_MODTREE_SHOWALLFILES, _T("Show &All Files"));
AppendMenu(hMenu, (m_showAllFiles) ? MF_STRING : (MF_STRING|MF_CHECKED), ID_MODTREE_SOUNDFILESONLY, _T("Show &Sound Files"));
bSep = TRUE;
}
if ((bSep) || (nDefault)) AppendMenu(hMenu, MF_SEPARATOR, NULL, _T(""));
AppendMenu(hMenu, MF_STRING, ID_MODTREE_REFRESH, _T("&Refresh"));
TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x + 4, pt.y, 0, m_hWnd, NULL);
DestroyMenu(hMenu);
}
}
}
void CModTree::OnItemLeftClick(LPNMHDR, LRESULT *pResult)
{
if(!(m_dwStatus & TREESTATUS_RDRAG))
{
POINT pt;
UINT flags = 0;
GetCursorPos(&pt);
ScreenToClient(&pt);
HTREEITEM hItem = HitTest(pt, &flags);
if(hItem != NULL)
{
const ModItem modItem = GetModItem(hItem);
const uint32 modItemID = modItem.val1;
switch(modItem.type)
{
case MODITEM_INSLIB_FOLDER:
case MODITEM_INSLIB_SONG:
if(m_dwStatus & TREESTATUS_SINGLEEXPAND)
ExecuteItem(hItem);
break;
case MODITEM_SAMPLE:
case MODITEM_INSTRUMENT:
{
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
CFrameWnd *pFrame = pMainFrm->GetActiveFrame();
if (pFrame)
{
pFrame->SendMessage(WM_MOD_INSTRSELECTED,
(modItem.type == MODITEM_INSTRUMENT) ? TRUE : FALSE,
(LPARAM)modItemID);
}
}
break;
case MODITEM_HDR_SONG:
ExecuteItem(hItem);
break;
}
}
}
if(pResult)
*pResult = 0;
}
void CModTree::OnEndDrag(DWORD dwMask)
{
if(m_dwStatus & dwMask)
{
m_dwStatus &= ~dwMask;
if(!(m_dwStatus & TREESTATUS_DRAGGING))
{
ReleaseCapture();
SetCursor(CMainFrame::curArrow);
SelectDropTarget(nullptr);
if(m_hItemDrop != nullptr)
{
CanDrop(m_hItemDrop, true);
} else if(m_hDropWnd)
{
DRAGONDROP dropinfo;
mpt::PathString fullPath;
if(GetDropInfo(dropinfo, fullPath))
{
if(dropinfo.dropType == DRAGONDROP_SONG)
{
theApp.OpenDocumentFile(fullPath.ToCString());
} else
{
::SendMessage(m_hDropWnd, WM_MOD_DRAGONDROPPING, TRUE, (LPARAM)&dropinfo);
}
}
}
}
}
}
void CModTree::OnLButtonUp(UINT nFlags, CPoint point)
{
OnEndDrag(TREESTATUS_LDRAG);
CTreeCtrl::OnLButtonUp(nFlags, point);
}
void CModTree::OnRButtonUp(UINT nFlags, CPoint point)
{
OnEndDrag(TREESTATUS_RDRAG);
CTreeCtrl::OnRButtonUp(nFlags, point);
}
void CModTree::OnXButtonUp(UINT nFlags, UINT nButton, CPoint point)
{
bool isSampleBrowser = IsSampleBrowser();
if(!isSampleBrowser)
{
// In the upper panel, only do folder navigation if the mouse cursor is somewhere below the "Instrument Library" item
CRect rect;
GetItemRect(m_hInsLib, rect, FALSE);
if(point.y > rect.top)
isSampleBrowser = true;
}
if(isSampleBrowser)
{
if(nButton == XBUTTON1)
{
InstrumentLibraryChDir(P_(".."), !m_SongFileName.empty());
} else if(nButton == XBUTTON2)
{
const auto &previousPath = CMainFrame::GetMainFrame()->GetUpperTreeview()->m_previousPath;
InstrumentLibraryChDir(previousPath, (m_InstrLibPath + previousPath).IsFile());
}
}
CTreeCtrl::OnXButtonUp(nFlags, nButton, point);
}
void CModTree::OnMouseMove(UINT nFlags, CPoint point)
{
if(m_dwStatus & TREESTATUS_DRAGGING)
{
HTREEITEM hItem;
UINT flags = 0;
// Bug?
if(!(nFlags & (MK_LBUTTON | MK_RBUTTON)))
{
m_itemDrag = ModItem(MODITEM_NULL);
m_hItemDrag = NULL;
OnEndDrag(TREESTATUS_DRAGGING);
return;
}
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
if(pMainFrm)
{
CRect rect;
GetClientRect(&rect);
if(rect.PtInRect(point))
{
m_hDropWnd = m_hWnd;
bool bCanDrop = CanDrop(HitTest(point, &flags), false);
SetCursor((bCanDrop) ? CMainFrame::curDragging : CMainFrame::curNoDrop2);
} else
{
CPoint screenPt = point;
ClientToScreen(&screenPt);
HWND hwnd = ::WindowFromPoint(screenPt);
if(hwnd != m_hDropWnd)
{
bool canDrop = false;
m_hDropWnd = hwnd;
if(hwnd == m_hWnd)
{
canDrop = true;
} else if(hwnd != NULL)
{
DRAGONDROP dropinfo;
mpt::PathString fullPath;
if(GetDropInfo(dropinfo, fullPath))
{
if(dropinfo.dropType == DRAGONDROP_SONG)
{
canDrop = true;
} else if(::SendMessage(hwnd, WM_MOD_DRAGONDROPPING, FALSE, (LPARAM)&dropinfo))
{
canDrop = true;
}
}
}
SetCursor(canDrop ? CMainFrame::curDragging : CMainFrame::curNoDrop);
if(canDrop)
{
if(GetDropHilightItem() != m_hItemDrag)
{
SelectDropTarget(m_hItemDrag);
}
m_hItemDrop = NULL;
return;
}
}
}
if((point.x >= -1) && (point.x <= rect.right + GetSystemMetrics(SM_CXVSCROLL)))
{
if(point.y <= 0)
{
HTREEITEM hfirst = GetFirstVisibleItem();
if(hfirst != NULL)
{
HTREEITEM hprev = GetPrevVisibleItem(hfirst);
if(hprev != NULL)
SelectSetFirstVisible(hprev);
}
} else if(point.y >= rect.bottom - 1)
{
hItem = HitTest(point, &flags);
HTREEITEM hNext = GetNextItem(hItem, TVGN_NEXTVISIBLE);
if(hNext != NULL)
{
EnsureVisible(hNext);
}
}
}
if((hItem = HitTest(point, &flags)) != NULL)
{
SelectDropTarget(hItem);
m_hItemDrop = hItem;
}
}
}
CTreeCtrl::OnMouseMove(nFlags, point);
}
void CModTree::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
switch(nChar)
{
case VK_DELETE:
DeleteTreeItem(GetSelectedItem());
break;
}
CTreeCtrl::OnKeyDown(nChar, nRepCnt, nFlags);
}
void CModTree::OnRefreshTree()
{
BeginWaitCursor();
for(auto &doc : m_docInfo)
{
UpdateView(doc.second, UpdateHint().ModType());
}
RefreshMidiLibrary();
RefreshDlsBanks();
RefreshInstrumentLibrary();
EndWaitCursor();
}
void CModTree::OnExecuteItem()
{
ExecuteItem(GetSelectedItem());
}
void CModTree::OnDeleteTreeItem()
{
DeleteTreeItem(GetSelectedItem());
}
void CModTree::OnPlayTreeItem()
{
PlayItem(GetSelectedItem(), NOTE_MIDDLEC);
}
void CModTree::OnOpenTreeItem()
{
OpenTreeItem(GetSelectedItem());
}
void CModTree::OnMuteTreeItem()
{
HTREEITEM hItem = GetSelectedItem();
const ModItem modItem = GetModItem(hItem);
const uint32 modItemID = modItem.val1;
ModTreeDocInfo *info = GetDocumentInfoFromItem(hItem);
if(info)
{
CModDoc &modDoc = info->modDoc;
if((modItem.type == MODITEM_SAMPLE) && !modDoc.GetNumInstruments())
{
modDoc.MuteSample((SAMPLEINDEX)modItemID, !modDoc.IsSampleMuted((SAMPLEINDEX)modItemID));
UpdateView(*info, SampleHint((SAMPLEINDEX)modItemID).Info().Names());
} else if((modItem.type == MODITEM_INSTRUMENT) && modDoc.GetNumInstruments())
{
modDoc.MuteInstrument((INSTRUMENTINDEX)modItemID, !modDoc.IsInstrumentMuted((INSTRUMENTINDEX)modItemID));
UpdateView(*info, InstrumentHint((INSTRUMENTINDEX)modItemID).Info().Names());
} else if(modItem.type == MODITEM_EFFECT)
{
IMixPlugin *pPlugin = modDoc.GetSoundFile().m_MixPlugins[modItemID].pMixPlugin;
if(pPlugin == nullptr)
return;
pPlugin->ToggleBypass();
if(modDoc.GetSoundFile().GetModSpecifications().supportsPlugins)
modDoc.SetModified();
//UpdateView(*info, PluginHint(static_cast<PLUGINDEX>(modItemID + 1)));
} else if(modItem.type == MODITEM_HDR_EFFECTS)
{
auto &sndFile = modDoc.GetSoundFile();
BypassAllPlugins(sndFile, !AllPluginsBypassed(sndFile, false), false);
}
}
}
void CModTree::OnMuteOnlyEffects()
{
HTREEITEM hItem = GetSelectedItem();
const ModItem modItem = GetModItem(hItem);
ModTreeDocInfo *info = GetDocumentInfoFromItem(hItem);
if(info)
{
CModDoc &modDoc = info->modDoc;
if(modItem.type == MODITEM_HDR_EFFECTS)
{
auto &sndFile = modDoc.GetSoundFile();
BypassAllPlugins(sndFile, !AllPluginsBypassed(sndFile, true), true);
}
}
}
void CModTree::OnSoloTreeItem()
{
HTREEITEM hItem = GetSelectedItem();
const ModItem modItem = GetModItem(hItem);
const uint32 modItemID = modItem.val1;
ModTreeDocInfo *info = GetDocumentInfoFromItem(hItem);
if(info)
{
CModDoc &modDoc = info->modDoc;
INSTRUMENTINDEX nInstruments = modDoc.GetNumInstruments();
if((modItem.type == MODITEM_SAMPLE) && (!nInstruments))
{
for(SAMPLEINDEX nSmp = 1; nSmp <= modDoc.GetNumSamples(); nSmp++)
{
modDoc.MuteSample(nSmp, nSmp != modItemID);
}
UpdateView(*info, SampleHint().Info().Names());
} else if((modItem.type == MODITEM_INSTRUMENT) && (nInstruments))
{
for(INSTRUMENTINDEX nIns = 1; nIns <= nInstruments; nIns++)
{
modDoc.MuteInstrument(nIns, nIns != modItemID);
}
UpdateView(*info, InstrumentHint().Info().Names());
}
}
}
void CModTree::OnUnmuteAllTreeItem()
{
HTREEITEM hItem = GetSelectedItem();
const ModItem modItem = GetModItem(hItem);
ModTreeDocInfo *info = GetDocumentInfoFromItem(hItem);
if(info)
{
CModDoc &modDoc = info->modDoc;
if((modItem.type == MODITEM_SAMPLE) || (modItem.type == MODITEM_INSTRUMENT))
{
for(SAMPLEINDEX nSmp = 1; nSmp <= modDoc.GetNumSamples(); nSmp++)
{
modDoc.MuteSample(nSmp, false);
}
UpdateView(*info, SampleHint().Info().Names());
for(INSTRUMENTINDEX nIns = 1; nIns <= modDoc.GetNumInstruments(); nIns++)
{
modDoc.MuteInstrument(nIns, false);
}
UpdateView(*info, InstrumentHint().Info().Names());
}
}
}
bool CModTree::HasEffectPlugins(const CSoundFile &sndFile)
{
for(const auto &plugin : sndFile.m_MixPlugins)
{
if(!plugin.pMixPlugin)
continue;
if(!plugin.pMixPlugin->IsInstrument())
return true;
}
return false;
}
bool CModTree::AllPluginsBypassed(const CSoundFile &sndFile, bool onlyEffects)
{
for(const auto &plugin : sndFile.m_MixPlugins)
{
if(!plugin.pMixPlugin)
continue;
if(onlyEffects && plugin.pMixPlugin->IsInstrument())
continue;
if(!plugin.IsBypassed())
return false;
}
return true;
}
void CModTree::BypassAllPlugins(CSoundFile &sndFile, bool bypass, bool onlyEffects)
{
bool modified = false;
for(auto &plugin : sndFile.m_MixPlugins)
{
if(!plugin.pMixPlugin)
continue;
if(onlyEffects && plugin.pMixPlugin->IsInstrument())
continue;
if(plugin.IsBypassed() != bypass)
{
plugin.pMixPlugin->Bypass(bypass);
modified = true;
}
}
if(modified && sndFile.GetModSpecifications().supportsPlugins && sndFile.GetpModDoc())
sndFile.GetpModDoc()->SetModified();
}
// Helper function for generating an insert vector for samples/instruments/sequences
template <typename T>
static std::vector<T> GenerateInsertVector(size_t howMany, size_t insertPos, T insertId, T startId)
{
std::vector<T> newOrder(howMany);
std::iota(newOrder.begin(), newOrder.end(), startId);
newOrder.insert(newOrder.begin() + insertPos, insertId);
return newOrder;
}
void CModTree::InsertOrDupItem(bool insert)
{
HTREEITEM hItem = GetSelectedItem();
const ModItem modItem = GetModItem(hItem);
const uint32 modItemID = modItem.val1;
ModTreeDocInfo *info = GetDocumentInfoFromItem(hItem);
if(info)
{
CModDoc &modDoc = info->modDoc;
CSoundFile &sndFile = modDoc.GetSoundFile();
if(modItem.type == MODITEM_SEQUENCE || modItem.type == MODITEM_HDR_ORDERS)
{
// Duplicate / insert sequence
const SEQUENCEINDEX newIndex = (modItem.type == MODITEM_HDR_ORDERS) ? sndFile.Order.GetNumSequences() : static_cast<SEQUENCEINDEX>(modItemID + 1);
std::vector<SEQUENCEINDEX> newOrder = GenerateInsertVector<SEQUENCEINDEX>(sndFile.Order.GetNumSequences(), newIndex, static_cast<SEQUENCEINDEX>(insert ? SEQUENCEINDEX_INVALID : modItemID), 0);
if(modDoc.ReArrangeSequences(newOrder) != SEQUENCEINDEX_INVALID)
{
sndFile.Order.SetSequence(newIndex);
if(const auto name = sndFile.Order().GetName(); !insert && !name.empty())
sndFile.Order().SetName(name + U_(" (Copy)"));
modDoc.UpdateAllViews(nullptr, SequenceHint(SEQUENCEINDEX_INVALID).Names().Data());
modDoc.SetModified();
} else
{
Reporting::Error("Maximum number of sequences reached.");
}
} else if(modItem.type == MODITEM_SAMPLE)
{
// Duplicate / insert sample
std::vector<SAMPLEINDEX> newOrder = GenerateInsertVector<SAMPLEINDEX>(sndFile.GetNumSamples(), modItemID, static_cast<SAMPLEINDEX>(insert ? 0 : modItemID), 1);
if(modDoc.ReArrangeSamples(newOrder) != SAMPLEINDEX_INVALID)
{
modDoc.SetModified();
modDoc.UpdateAllViews(nullptr, SampleHint().Info().Data().Names());
modDoc.UpdateAllViews(nullptr, PatternHint().Data());
} else
{
Reporting::Error("Maximum number of samples reached.");
}
} else if(modItem.type == MODITEM_INSTRUMENT)
{
// Duplicate / insert instrument
std::vector<INSTRUMENTINDEX> newOrder = GenerateInsertVector<INSTRUMENTINDEX>(sndFile.GetNumInstruments(), modItemID, static_cast<INSTRUMENTINDEX>(insert ? 0 : modItemID), 1);
if(modDoc.ReArrangeInstruments(newOrder) != INSTRUMENTINDEX_INVALID)
{
modDoc.UpdateAllViews(NULL, InstrumentHint().Info().Envelope().Names());
modDoc.UpdateAllViews(nullptr, PatternHint().Data());
modDoc.SetModified();
} else
{
Reporting::Error("Maximum number of instruments reached.");
}
}
}
}
void CModTree::OnSwitchToTreeItem()
{
HTREEITEM hItem = GetSelectedItem();
const ModItem modItem = GetModItem(hItem);
CModDoc *pModDoc = GetDocumentFromItem(hItem);
if(pModDoc && (modItem.type == MODITEM_SEQUENCE))
{
pModDoc->ActivateView(IDD_CONTROL_PATTERNS, uint32(modItem.val1 << SEQU_SHIFT) | SEQU_INDICATOR);
}
}
void CModTree::OnSetItemPath()
{
HTREEITEM hItem = GetSelectedItem();
const ModItem modItem = GetModItem(hItem);
CModDoc *pModDoc = GetDocumentFromItem(hItem);
if(pModDoc && modItem.val1)
{
SAMPLEINDEX smpID = static_cast<SAMPLEINDEX>(modItem.val1);
const mpt::PathString path = pModDoc->GetSoundFile().GetSamplePath(smpID);
FileDialog dlg = OpenFileDialog()
.ExtensionFilter("All Samples|*.wav;*.flac|All files(*.*)|*.*||"); // Only show samples that we actually can save as well.
if(path.empty())
dlg.WorkingDirectory(TrackerSettings::Instance().PathSamples.GetWorkingDir());
else
dlg.DefaultFilename(path);
if(!dlg.Show())
return;
TrackerSettings::Instance().PathSamples.SetWorkingDir(dlg.GetWorkingDirectory());
if(dlg.GetFirstFile() != pModDoc->GetSoundFile().GetSamplePath(smpID))
{
pModDoc->GetSoundFile().SetSamplePath(smpID, dlg.GetFirstFile());
pModDoc->SetModified();
}
OnReloadItem();
}
}
void CModTree::OnSaveItem()
{
HTREEITEM hItem = GetSelectedItem();
const ModItem modItem = GetModItem(hItem);
CModDoc *pModDoc = GetDocumentFromItem(hItem);
if(pModDoc && modItem.val1)
{
SAMPLEINDEX smpID = static_cast<SAMPLEINDEX>(modItem.val1);
pModDoc->SaveSample(smpID);
if(pModDoc)
pModDoc->UpdateAllViews(NULL, SampleHint(smpID).Info());
OnRefreshTree();
}
}
void CModTree::OnSaveAll()
{
CModDoc *pModDoc = GetDocumentFromItem(GetSelectedItem());
if(pModDoc != nullptr)
{
pModDoc->SaveAllSamples(false);
if(pModDoc)
pModDoc->UpdateAllViews(nullptr, SampleHint().Info());
OnRefreshTree();
}
}
void CModTree::OnReloadItem()
{
HTREEITEM hItem = GetSelectedItem();
const ModItem modItem = GetModItem(hItem);
CModDoc *pModDoc = GetDocumentFromItem(hItem);
if(pModDoc && modItem.val1)
{
SAMPLEINDEX smpID = static_cast<SAMPLEINDEX>(modItem.val1);
CSoundFile &sndFile = pModDoc->GetSoundFile();
pModDoc->GetSampleUndo().PrepareUndo(smpID, sundo_replace, "Replace");
if(!sndFile.LoadExternalSample(smpID, sndFile.GetSamplePath(smpID)))
{
pModDoc->GetSampleUndo().RemoveLastUndoStep(smpID);
Reporting::Error(_T("Unable to load sample:\n") + sndFile.GetSamplePath(smpID).AsNative());
} else
{
if(!sndFile.GetSample(smpID).uFlags[SMP_KEEPONDISK])
{
pModDoc->SetModified();
}
pModDoc->UpdateAllViews(NULL, SampleHint(smpID).Info().Data().Names());
}
OnRefreshTree();
}
}
void CModTree::OnReloadAll()
{
CModDoc *pModDoc = GetDocumentFromItem(GetSelectedItem());
if(pModDoc != nullptr)
{
CSoundFile &sndFile = pModDoc->GetSoundFile();
bool anyMissing = false;
for(SAMPLEINDEX smp = 1; smp <= sndFile.GetNumSamples(); smp++)
{
const mpt::PathString &path = sndFile.GetSamplePath(smp);
if(path.empty())
continue;
pModDoc->GetSampleUndo().PrepareUndo(smp, sundo_replace, "Replace");
if(!sndFile.LoadExternalSample(smp, path))
{
pModDoc->GetSampleUndo().RemoveLastUndoStep(smp);
anyMissing = true;
} else
{
if(!sndFile.GetSample(smp).uFlags[SMP_KEEPONDISK])
{
pModDoc->SetModified();
}
}
}
pModDoc->UpdateAllViews(nullptr, SampleHint().Info().Data().Names());
OnRefreshTree();
if(anyMissing)
{
OnFindMissing();
}
}
}
// Find missing external samples
void CModTree::OnFindMissing()
{
CModDoc *pModDoc = GetDocumentFromItem(GetSelectedItem());
if(pModDoc == nullptr)
{
return;
}
MissingExternalSamplesDlg dlg(*pModDoc, CMainFrame::GetMainFrame());
dlg.DoModal();
}
void CModTree::OnAddDlsBank()
{
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
if(pMainFrm)
pMainFrm->OnAddDlsBank();
}
void CModTree::OnImportMidiLib()
{
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
if(pMainFrm)
pMainFrm->OnImportMidiLib();
}
void CModTree::OnExportMidiLib()
{
FileDialog dlg = SaveFileDialog()
.DefaultExtension("ini")
.DefaultFilename("mptrack.ini")
.ExtensionFilter("Text and INI files (*.txt,*.ini)|*.txt;*.ini|"
"All Files (*.*)|*.*||");
if(!dlg.Show()) return;
CTrackApp::ExportMidiConfig(dlg.GetFirstFile());
}
///////////////////////////////////////////////////////////////////////
// Drop support
DROPEFFECT CModTree::OnDragEnter(COleDataObject *, DWORD, CPoint)
{
return DROPEFFECT_LINK;
}
DROPEFFECT CModTree::OnDragOver(COleDataObject *, DWORD, CPoint point)
{
UINT flags = 0;
HTREEITEM hItem = HitTest(point, &flags);
const ModItem modItem = GetModItem(hItem);
switch(modItem.type)
{
case MODITEM_MIDIINSTRUMENT:
case MODITEM_MIDIPERCUSSION:
if(hItem != GetDropHilightItem())
{
SelectDropTarget(hItem);
EnsureVisible(hItem);
}
m_hItemDrag = hItem;
m_itemDrag = modItem;
return DROPEFFECT_LINK;
// Folders:
case MODITEM_HDR_MIDILIB:
case MODITEM_HDR_MIDIGROUP:
EnsureVisible(GetChildItem(hItem));
break;
}
return DROPEFFECT_NONE;
}
BOOL CModTree::OnDrop(COleDataObject *pDataObject, DROPEFFECT, CPoint)
{
STGMEDIUM stgm;
HDROP hDropInfo;
UINT nFiles;
BOOL bOk = FALSE;
if(!pDataObject)
return FALSE;
if(!pDataObject->GetData(CF_HDROP, &stgm))
return FALSE;
if(stgm.tymed != TYMED_HGLOBAL)
return FALSE;
if(stgm.hGlobal == NULL)
return FALSE;
hDropInfo = (HDROP)stgm.hGlobal;
nFiles = DragQueryFile(hDropInfo, (UINT)-1, NULL, 0);
if(nFiles)
{
UINT size = ::DragQueryFile(hDropInfo, 0, nullptr, 0) + 1;
std::vector<TCHAR> fileName(size, _T('\0'));
if(DragQueryFile(hDropInfo, 0, fileName.data(), size))
{
switch(m_itemDrag.type)
{
case MODITEM_MIDIINSTRUMENT:
bOk = SetMidiInstrument(m_itemDrag.val1, mpt::PathString::FromNative(fileName.data()));
break;
case MODITEM_MIDIPERCUSSION:
bOk = SetMidiPercussion(m_itemDrag.val1, mpt::PathString::FromNative(fileName.data()));
break;
}
}
}
// After dropping some file on the MIDI library, we will need to do this or you
// won't be able to select a new item until you started a new (internal) dragondrop.
if(m_hItemDrag)
{
OnBeginDrag(m_hItemDrag, true, nullptr);
OnEndDrag(TREESTATUS_DRAGGING);
}
m_itemDrag = ModItem(MODITEM_NULL);
m_hItemDrag = NULL;
::DragFinish(hDropInfo);
return bOk;
}
void CModTree::OnRefreshInstrLib()
{
BeginWaitCursor();
RefreshInstrumentLibrary();
EndWaitCursor();
}
void CModTree::OnShowDirectories()
{
TrackerSettings::Instance().showDirsInSampleBrowser = !TrackerSettings::Instance().showDirsInSampleBrowser;
OnRefreshInstrLib();
}
void CModTree::OnShowAllFiles()
{
if(!m_showAllFiles)
{
m_showAllFiles = true;
OnRefreshInstrLib();
}
}
void CModTree::OnShowSoundFiles()
{
if(m_showAllFiles)
{
m_showAllFiles = false;
OnRefreshInstrLib();
}
}
void CModTree::OnGotoInstrumentDir()
{
SetFullInstrumentLibraryPath(TrackerSettings::Instance().PathInstruments.GetDefaultDir());
}
void CModTree::OnGotoSampleDir()
{
SetFullInstrumentLibraryPath(TrackerSettings::Instance().PathSamples.GetDefaultDir());
}
void CModTree::OnSoundBankProperties()
{
const ModItem modItem = GetModItem(GetSelectedItem());
if(modItem.type == MODITEM_DLSBANK_FOLDER
&& modItem.val1 < CTrackApp::gpDLSBanks.size() && CTrackApp::gpDLSBanks[modItem.val1])
{
CSoundBankProperties dlg(*CTrackApp::gpDLSBanks[modItem.val1], this);
dlg.DoModal();
}
}
LRESULT CModTree::OnCustomKeyMsg(WPARAM wParam, LPARAM /*lParam*/)
{
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
ModCommand::NOTE note = NOTE_NONE;
const bool start = wParam >= kcTreeViewStartNotes && wParam <= kcTreeViewEndNotes,
stop = (wParam >= kcTreeViewStartNoteStops && wParam <= kcTreeViewEndNoteStops) && !IsSampleBrowser();
if(start || stop)
{
const ModItem modItem = GetModItem(GetSelectedItem());
CModDoc *modDoc = m_docInfo.count(m_selectedDoc) ? m_selectedDoc : nullptr;
const int noteOffset = static_cast<int>(wParam - (start ? kcTreeViewStartNotes : kcTreeViewStartNoteStops));
note = static_cast<ModCommand::NOTE>(Clamp(NOTE_MIN + pMainFrm->GetBaseOctave() * 12 + noteOffset, NOTE_MIN, NOTE_MAX));
if(modDoc && modItem.type == MODITEM_INSTRUMENT)
note = modDoc->GetNoteWithBaseOctave(noteOffset, static_cast<INSTRUMENTINDEX>(modItem.val1));
} else if(wParam == kcTreeViewStopPreview)
{
note = NOTE_NOTECUT;
}
if(note != NOTE_NONE)
{
if(stop)
note |= 0x80;
if(PlayItem(GetSelectedItem(), note))
return wParam;
else
return kcNull;
}
return kcNull;
}
LRESULT CModTree::OnMidiMsg(WPARAM midiData_, LPARAM)
{
uint32 midiData = static_cast<uint32>(midiData_);
// Handle MIDI messages assigned to shortcuts
CInputHandler *ih = CMainFrame::GetInputHandler();
ih->HandleMIDIMessage(kCtxViewTree, midiData) != kcNull
|| ih->HandleMIDIMessage(kCtxAllContexts, midiData) != kcNull;
uint8 midiByte1 = MIDIEvents::GetDataByte1FromEvent(midiData);
int volume;
switch(MIDIEvents::GetTypeFromEvent(midiData))
{
case MIDIEvents::evNoteOn:
volume = MIDIEvents::GetDataByte2FromEvent(midiData);
if(volume > 0)
{
PlayItem(GetSelectedItem(), midiByte1 + NOTE_MIN, Util::muldivr(volume, 256, 127));
return 1;
}
[[fallthrough]];
case MIDIEvents::evNoteOff:
PlayItem(GetSelectedItem(), NOTE_NOTECUT);
return 1;
}
return 0;
}
void CModTree::OnKillFocus(CWnd *pNewWnd)
{
CTreeCtrl::OnKillFocus(pNewWnd);
CMainFrame::GetMainFrame()->m_bModTreeHasFocus = false;
if(pNewWnd != nullptr)
CMainFrame::GetMainFrame()->SetMidiRecordWnd(pNewWnd->m_hWnd);
}
void CModTree::OnSetFocus(CWnd *pOldWnd)
{
CTreeCtrl::OnSetFocus(pOldWnd);
CMainFrame::GetMainFrame()->m_bModTreeHasFocus = true;
CMainFrame::GetMainFrame()->SetMidiRecordWnd(m_hWnd);
}
bool CModTree::IsItemExpanded(HTREEITEM hItem)
{
// checks if a treeview item is expanded.
if(hItem == NULL)
return false;
TVITEM tvi;
tvi.mask = TVIF_HANDLE | TVIF_STATE;
tvi.state = 0;
tvi.stateMask = TVIS_EXPANDED;
tvi.hItem = hItem;
GetItem(&tvi);
return (tvi.state & TVIS_EXPANDED) != 0;
}
void CModTree::OnCloseItem()
{
HTREEITEM hItem = GetSelectedItem();
if(hItem == m_hInsLib && !m_SongFileName.empty())
{
InstrumentLibraryChDir(P_(".."), true);
return;
}
CModDoc *pModDoc = GetDocumentFromItem(hItem);
if(pModDoc == nullptr)
return;
// Spam our message to the first available view
POSITION pos = pModDoc->GetFirstViewPosition();
if(pos == nullptr)
return;
CView *pView = pModDoc->GetNextView(pos);
if(pView)
pView->PostMessage(WM_COMMAND, ID_FILE_CLOSE);
}
// Delete all children of a tree item
void CModTree::DeleteChildren(HTREEITEM hItem)
{
if(hItem != nullptr)
{
HTREEITEM hChildItem;
while((hChildItem = GetChildItem(hItem)) != nullptr)
{
DeleteItem(hChildItem);
}
}
}
// Get the n-th child of a tree node
HTREEITEM CModTree::GetNthChildItem(HTREEITEM hItem, int index) const
{
HTREEITEM hChildItem = nullptr;
if(hItem != nullptr && ItemHasChildren(hItem))
{
hChildItem = GetChildItem(hItem);
while(index-- > 0)
{
hChildItem = GetNextSiblingItem(hChildItem);
}
}
return hChildItem;
}
// Gets the root parent of an item, i.e. if C is a child of B and B is a child of A, GetParentRootItem(C) returns A.
// A root item is considered to be its own parent, i.e. the returned value is only ever NULL if the input value was NULL.
HTREEITEM CModTree::GetParentRootItem(HTREEITEM hItem) const
{
while(hItem != nullptr)
{
const HTREEITEM h = GetParentItem(hItem);
if(h == nullptr || h == hItem)
break;
hItem = h;
}
return hItem;
}
void CModTree::OnRenameItem()
{
EditLabel(GetSelectedItem());
}
// Editing sample, instrument, order, pattern, etc. labels
void CModTree::OnBeginLabelEdit(NMHDR *nmhdr, LRESULT *result)
{
NMTVDISPINFO *info = reinterpret_cast<NMTVDISPINFO *>(nmhdr);
CEdit *editCtrl = GetEditControl();
if(editCtrl == nullptr)
return;
const ModItem modItem = GetModItem(info->item.hItem);
const CModDoc *modDoc = modItem.IsSongItem() ? GetDocumentFromItem(info->item.hItem) : nullptr;
mpt::ustring text;
m_doLabelEdit = false;
if(modDoc != nullptr)
{
const CSoundFile &sndFile = modDoc->GetSoundFile();
const CModSpecifications &modSpecs = sndFile.GetModSpecifications();
switch(modItem.type)
{
case MODITEM_HDR_SONG:
text = mpt::ToUnicode(sndFile.GetCharsetInternal(), sndFile.m_songName);
editCtrl->SetLimitText(modSpecs.modNameLengthMax);
m_doLabelEdit = true;
break;
case MODITEM_ORDER:
{
PATTERNINDEX pat = sndFile.Order(static_cast<SEQUENCEINDEX>(modItem.val2)).at(static_cast<ORDERINDEX>(modItem.val1));
if(pat == sndFile.Order.GetInvalidPatIndex())
text = UL_("---");
else if(pat == sndFile.Order.GetIgnoreIndex())
text = UL_("+++");
else
text = mpt::ufmt::val(pat);
m_doLabelEdit = true;
}
break;
case MODITEM_HDR_ORDERS:
if(sndFile.Order.GetNumSequences() != 1 || sndFile.GetModSpecifications().sequencesMax <= 1)
{
break;
}
[[fallthrough]];
case MODITEM_SEQUENCE:
if(modItem.val1 < sndFile.Order.GetNumSequences())
{
text = sndFile.Order(static_cast<SEQUENCEINDEX>(modItem.val1)).GetName();
m_doLabelEdit = true;
}
break;
case MODITEM_PATTERN:
if(modItem.val1 < sndFile.Patterns.GetNumPatterns() && modSpecs.hasPatternNames)
{
text = mpt::ToUnicode(sndFile.GetCharsetInternal(), sndFile.Patterns[modItem.val1].GetName());
editCtrl->SetLimitText(MAX_PATTERNNAME - 1);
m_doLabelEdit = true;
}
break;
case MODITEM_SAMPLE:
if(modItem.val1 <= sndFile.GetNumSamples())
{
text = mpt::ToUnicode(sndFile.GetCharsetInternal(), sndFile.m_szNames[modItem.val1]);
editCtrl->SetLimitText(modSpecs.sampleNameLengthMax);
m_doLabelEdit = true;
}
break;
case MODITEM_INSTRUMENT:
if(modItem.val1 <= sndFile.GetNumInstruments() && sndFile.Instruments[modItem.val1] != nullptr)
{
text = mpt::ToUnicode(sndFile.GetCharsetInternal(), sndFile.Instruments[modItem.val1]->name);
editCtrl->SetLimitText(modSpecs.instrNameLengthMax);
m_doLabelEdit = true;
}
break;
}
} else if(modItem.type == MODITEM_HDR_INSTRUMENTLIB)
{
text = m_InstrLibPath.ToUnicode();
m_doLabelEdit = true;
}
if(m_doLabelEdit)
{
CMainFrame::GetInputHandler()->Bypass(true);
editCtrl->SetWindowText(mpt::ToCString(text));
}
*result = m_doLabelEdit ? FALSE : TRUE;
}
// End editing sample, instrument, order, pattern, etc. labels
void CModTree::OnEndLabelEdit(NMHDR *nmhdr, LRESULT *result)
{
CMainFrame::GetInputHandler()->Bypass(false);
m_doLabelEdit = false;
NMTVDISPINFO *info = reinterpret_cast<NMTVDISPINFO *>(nmhdr);
const ModItem modItem = GetModItem(info->item.hItem);
CModDoc *modDoc = modItem.IsSongItem() ? GetDocumentFromItem(info->item.hItem) : nullptr;
*result = FALSE;
if(info->item.pszText == nullptr)
return;
if(modDoc != nullptr)
{
CSoundFile &sndFile = modDoc->GetSoundFile();
const CModSpecifications &modSpecs = sndFile.GetModSpecifications();
const mpt::ustring itemText = mpt::ToUnicode(CString(info->item.pszText));
switch(modItem.type)
{
case MODITEM_HDR_SONG:
if(mpt::ToUnicode(sndFile.GetCharsetInternal(), sndFile.m_songName) != itemText)
{
sndFile.m_songName = mpt::truncate(mpt::ToCharset(sndFile.GetCharsetInternal(), itemText), modSpecs.modNameLengthMax);
modDoc->SetModified();
modDoc->UpdateAllViews(nullptr, GeneralHint().General());
}
break;
case MODITEM_ORDER:
if(!itemText.empty())
{
PATTERNINDEX pat = ConvertStrTo<PATTERNINDEX>(itemText);
bool valid = true;
if(itemText[0] == UC_('-'))
{
pat = sndFile.Order.GetInvalidPatIndex();
} else if(itemText[0] == UC_('+'))
{
if(modSpecs.hasIgnoreIndex)
pat = sndFile.Order.GetIgnoreIndex();
else
valid = false;
} else
{
valid = (pat < sndFile.Patterns.GetNumPatterns());
}
PATTERNINDEX &target = sndFile.Order(static_cast<SEQUENCEINDEX>(modItem.val2))[static_cast<ORDERINDEX>(modItem.val1)];
if(valid && pat != target)
{
target = pat;
modDoc->SetModified();
modDoc->UpdateAllViews(nullptr, SequenceHint().Data());
}
} else
{
MessageBeep(MB_ICONWARNING);
}
break;
case MODITEM_HDR_ORDERS:
case MODITEM_SEQUENCE:
if(modItem.val1 < sndFile.Order.GetNumSequences() && sndFile.Order(static_cast<SEQUENCEINDEX>(modItem.val1)).GetName() != itemText)
{
sndFile.Order(static_cast<SEQUENCEINDEX>(modItem.val1)).SetName(itemText);
modDoc->SetModified();
modDoc->UpdateAllViews(nullptr, SequenceHint(static_cast<SEQUENCEINDEX>(modItem.val1)).Names());
}
break;
case MODITEM_PATTERN:
if(modItem.val1 < sndFile.Patterns.GetNumPatterns() && modSpecs.hasPatternNames && mpt::ToUnicode(sndFile.GetCharsetInternal(), sndFile.Patterns[modItem.val1].GetName()) != itemText)
{
sndFile.Patterns[modItem.val1].SetName(mpt::ToCharset(sndFile.GetCharsetInternal(), itemText));
modDoc->SetModified();
modDoc->UpdateAllViews(nullptr, PatternHint(static_cast<PATTERNINDEX>(modItem.val1)).Data().Names());
}
break;
case MODITEM_SAMPLE:
if(modItem.val1 <= sndFile.GetNumSamples() && mpt::ToUnicode(sndFile.GetCharsetInternal(), sndFile.m_szNames[modItem.val1]) != itemText)
{
sndFile.m_szNames[modItem.val1] = mpt::truncate(mpt::ToCharset(sndFile.GetCharsetInternal(), itemText), modSpecs.sampleNameLengthMax);
modDoc->SetModified();
modDoc->UpdateAllViews(nullptr, SampleHint(static_cast<SAMPLEINDEX>(modItem.val1)).Info().Names());
}
break;
case MODITEM_INSTRUMENT:
if(modItem.val1 <= sndFile.GetNumInstruments() && sndFile.Instruments[modItem.val1] != nullptr && mpt::ToUnicode(sndFile.GetCharsetInternal(), sndFile.Instruments[modItem.val1]->name) != itemText)
{
sndFile.Instruments[modItem.val1]->name = mpt::truncate(mpt::ToCharset(sndFile.GetCharsetInternal(), itemText), modSpecs.instrNameLengthMax);
modDoc->SetModified();
modDoc->UpdateAllViews(nullptr, InstrumentHint(static_cast<INSTRUMENTINDEX>(modItem.val1)).Info().Names());
}
break;
}
} else if(modItem.type == MODITEM_HDR_INSTRUMENTLIB)
{
SetFullInstrumentLibraryPath(mpt::PathString::FromNative(info->item.pszText));
}
}
// Drop files from Windows
void CModTree::OnDropFiles(HDROP hDropInfo)
{
bool refreshDLS = false;
const UINT nFiles = ::DragQueryFile(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, _T('\0'));
if(::DragQueryFile(hDropInfo, f, fileName.data(), size))
{
mpt::PathString file(mpt::PathString::FromNative(fileName.data()));
if(IsSampleBrowser())
{
// Set sample browser location to this directory or file
SetFullInstrumentLibraryPath(file);
break;
} else
{
if(CTrackApp::AddDLSBank(file))
{
refreshDLS = true;
} else
{
// Pass message on
theApp.OpenDocumentFile(file.ToCString());
}
}
}
}
if(refreshDLS)
{
RefreshDlsBanks();
}
::DragFinish(hDropInfo);
}
OPENMPT_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink