4506 lines
131 KiB
C++
4506 lines
131 KiB
C++
/*
|
|
* 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
|