Cool_Tools/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-22 19:45:52 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
20d28e80a5
winamp/Src/external_dependencies/openmpt-trunk/mptrack/View_pat.cpp
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

7321 lines
226 KiB
C++
Raw Blame History

/*
* View_pat.cpp
* ------------
* Purpose: Pattern tab, lower panel.
* Notes : Welcome to about 7000 lines of, err, very beautiful code.
* Authors: Olivier Lapicque
* OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "Mptrack.h"
#include "Mainfrm.h"
#include "InputHandler.h"
#include "Childfrm.h"
#include "Moddoc.h"
#include "SampleEditorDialogs.h" // For amplification dialog (which is re-used from sample editor)
#include "Globals.h"
#include "View_pat.h"
#include "Ctrl_pat.h"
#include "PatternFont.h"
#include "PatternFindReplace.h"
#include "PatternFindReplaceDlg.h"
#include "EffectVis.h"
#include "PatternGotoDialog.h"
#include "MIDIMacros.h"
#include "../common/misc_util.h"
#include "../soundlib/MIDIEvents.h"
#include "../soundlib/mod_specifications.h"
#include "../soundlib/plugins/PlugInterface.h"
#include <algorithm>
OPENMPT_NAMESPACE_BEGIN
// Static initializers
ModCommand CViewPattern::m_cmdOld = ModCommand::Empty();
int32 CViewPattern::m_nTransposeAmount = 1;
IMPLEMENT_SERIAL(CViewPattern, CModScrollView, 0)
BEGIN_MESSAGE_MAP(CViewPattern, CModScrollView)
//{{AFX_MSG_MAP(CViewPattern)
ON_WM_ERASEBKGND()
ON_WM_VSCROLL()
ON_WM_SIZE()
ON_WM_MOUSEWHEEL()
ON_WM_XBUTTONUP()
ON_WM_MOUSEMOVE()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONDBLCLK()
ON_WM_LBUTTONUP()
ON_WM_RBUTTONDOWN()
ON_WM_SETFOCUS()
ON_WM_KILLFOCUS()
ON_WM_SYSKEYDOWN()
ON_WM_DESTROY()
ON_MESSAGE(WM_MOD_KEYCOMMAND, &CViewPattern::OnCustomKeyMsg)
ON_MESSAGE(WM_MOD_MIDIMSG, &CViewPattern::OnMidiMsg)
ON_MESSAGE(WM_MOD_RECORDPARAM, &CViewPattern::OnRecordPlugParamChange)
ON_COMMAND(ID_EDIT_CUT, &CViewPattern::OnEditCut)
ON_COMMAND(ID_EDIT_COPY, &CViewPattern::OnEditCopy)
ON_COMMAND(ID_EDIT_PASTE, &CViewPattern::OnEditPaste)
ON_COMMAND(ID_EDIT_MIXPASTE, &CViewPattern::OnEditMixPaste)
ON_COMMAND(ID_EDIT_MIXPASTE_ITSTYLE,&CViewPattern::OnEditMixPasteITStyle)
ON_COMMAND(ID_EDIT_PASTEFLOOD, &CViewPattern::OnEditPasteFlood)
ON_COMMAND(ID_EDIT_PUSHFORWARDPASTE,&CViewPattern::OnEditPushForwardPaste)
ON_COMMAND(ID_EDIT_SELECT_ALL, &CViewPattern::OnEditSelectAll)
ON_COMMAND(ID_EDIT_SELECTCOLUMN,&CViewPattern::OnEditSelectChannel)
ON_COMMAND(ID_EDIT_SELECTCOLUMN2,&CViewPattern::OnSelectCurrentChannel)
ON_COMMAND(ID_EDIT_FIND, &CViewPattern::OnEditFind)
ON_COMMAND(ID_EDIT_GOTO_MENU, &CViewPattern::OnEditGoto)
ON_COMMAND(ID_EDIT_FINDNEXT, &CViewPattern::OnEditFindNext)
ON_COMMAND(ID_EDIT_RECSELECT, &CViewPattern::OnRecordSelect)
ON_COMMAND(ID_EDIT_SPLITRECSELECT, &CViewPattern::OnSplitRecordSelect)
ON_COMMAND(ID_EDIT_SPLITKEYBOARDSETTINGS, &CViewPattern::SetSplitKeyboardSettings)
ON_COMMAND(ID_EDIT_UNDO, &CViewPattern::OnEditUndo)
ON_COMMAND(ID_EDIT_REDO, &CViewPattern::OnEditRedo)
ON_COMMAND(ID_PATTERN_CHNRESET, &CViewPattern::OnChannelReset)
ON_COMMAND(ID_PATTERN_MUTE, &CViewPattern::OnMuteFromClick)
ON_COMMAND(ID_PATTERN_SOLO, &CViewPattern::OnSoloFromClick)
ON_COMMAND(ID_PATTERN_TRANSITIONMUTE, &CViewPattern::OnTogglePendingMuteFromClick)
ON_COMMAND(ID_PATTERN_TRANSITIONSOLO, &CViewPattern::OnPendingSoloChnFromClick)
ON_COMMAND(ID_PATTERN_TRANSITION_UNMUTEALL, &CViewPattern::OnPendingUnmuteAllChnFromClick)
ON_COMMAND(ID_PATTERN_UNMUTEALL,&CViewPattern::OnUnmuteAll)
ON_COMMAND(ID_PATTERN_SPLIT, &CViewPattern::OnSplitPattern)
ON_COMMAND(ID_NEXTINSTRUMENT, &CViewPattern::OnNextInstrument)
ON_COMMAND(ID_PREVINSTRUMENT, &CViewPattern::OnPrevInstrument)
ON_COMMAND(ID_PATTERN_PLAYROW, &CViewPattern::OnPatternStep)
ON_COMMAND(IDC_PATTERN_RECORD, &CViewPattern::OnPatternRecord)
ON_COMMAND(ID_PATTERN_DELETEROW, &CViewPattern::OnDeleteRow)
ON_COMMAND(ID_PATTERN_DELETEALLROW, &CViewPattern::OnDeleteWholeRow)
ON_COMMAND(ID_PATTERN_DELETEROWGLOBAL, &CViewPattern::OnDeleteRowGlobal)
ON_COMMAND(ID_PATTERN_DELETEALLROWGLOBAL, &CViewPattern::OnDeleteWholeRowGlobal)
ON_COMMAND(ID_PATTERN_INSERTROW, &CViewPattern::OnInsertRow)
ON_COMMAND(ID_PATTERN_INSERTALLROW, &CViewPattern::OnInsertWholeRow)
ON_COMMAND(ID_PATTERN_INSERTROWGLOBAL, &CViewPattern::OnInsertRowGlobal)
ON_COMMAND(ID_PATTERN_INSERTALLROWGLOBAL, &CViewPattern::OnInsertWholeRowGlobal)
ON_COMMAND(ID_RUN_SCRIPT, &CViewPattern::OnRunScript)
ON_COMMAND(ID_TRANSPOSE_UP, &CViewPattern::OnTransposeUp)
ON_COMMAND(ID_TRANSPOSE_DOWN, &CViewPattern::OnTransposeDown)
ON_COMMAND(ID_TRANSPOSE_OCTUP, &CViewPattern::OnTransposeOctUp)
ON_COMMAND(ID_TRANSPOSE_OCTDOWN, &CViewPattern::OnTransposeOctDown)
ON_COMMAND(ID_TRANSPOSE_CUSTOM, &CViewPattern::OnTransposeCustom)
ON_COMMAND(ID_PATTERN_PROPERTIES, &CViewPattern::OnPatternProperties)
ON_COMMAND(ID_PATTERN_INTERPOLATE_VOLUME, &CViewPattern::OnInterpolateVolume)
ON_COMMAND(ID_PATTERN_INTERPOLATE_EFFECT, &CViewPattern::OnInterpolateEffect)
ON_COMMAND(ID_PATTERN_INTERPOLATE_NOTE, &CViewPattern::OnInterpolateNote)
ON_COMMAND(ID_PATTERN_INTERPOLATE_INSTR, &CViewPattern::OnInterpolateInstr)
ON_COMMAND(ID_PATTERN_VISUALIZE_EFFECT, &CViewPattern::OnVisualizeEffect)
ON_COMMAND(ID_GROW_SELECTION, &CViewPattern::OnGrowSelection)
ON_COMMAND(ID_SHRINK_SELECTION, &CViewPattern::OnShrinkSelection)
ON_COMMAND(ID_PATTERN_SETINSTRUMENT, &CViewPattern::OnSetSelInstrument)
ON_COMMAND(ID_PATTERN_ADDCHANNEL_FRONT, &CViewPattern::OnAddChannelFront)
ON_COMMAND(ID_PATTERN_ADDCHANNEL_AFTER, &CViewPattern::OnAddChannelAfter)
ON_COMMAND(ID_PATTERN_RESETCHANNELCOLORS, &CViewPattern::OnResetChannelColors)
ON_COMMAND(ID_PATTERN_TRANSPOSECHANNEL, &CViewPattern::OnTransposeChannel)
ON_COMMAND(ID_PATTERN_DUPLICATECHANNEL, &CViewPattern::OnDuplicateChannel)
ON_COMMAND(ID_PATTERN_REMOVECHANNEL, &CViewPattern::OnRemoveChannel)
ON_COMMAND(ID_PATTERN_REMOVECHANNELDIALOG, &CViewPattern::OnRemoveChannelDialog)
ON_COMMAND(ID_PATTERN_AMPLIFY, &CViewPattern::OnPatternAmplify)
ON_COMMAND(ID_CLEAR_SELECTION, &CViewPattern::OnClearSelectionFromMenu)
ON_COMMAND(ID_SHOWTIMEATROW, &CViewPattern::OnShowTimeAtRow)
ON_COMMAND(ID_PATTERN_EDIT_PCNOTE_PLUGIN, &CViewPattern::OnTogglePCNotePluginEditor)
ON_COMMAND(ID_SETQUANTIZE, &CViewPattern::OnSetQuantize)
ON_COMMAND(ID_LOCK_PATTERN_ROWS, &CViewPattern::OnLockPatternRows)
ON_COMMAND_RANGE(ID_CHANGE_INSTRUMENT, ID_CHANGE_INSTRUMENT+MAX_INSTRUMENTS, &CViewPattern::OnSelectInstrument)
ON_COMMAND_RANGE(ID_CHANGE_PCNOTE_PARAM, ID_CHANGE_PCNOTE_PARAM + ModCommand::maxColumnValue, &CViewPattern::OnSelectPCNoteParam)
ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, &CViewPattern::OnUpdateUndo)
ON_UPDATE_COMMAND_UI(ID_EDIT_REDO, &CViewPattern::OnUpdateRedo)
ON_COMMAND_RANGE(ID_PLUGSELECT, ID_PLUGSELECT+MAX_MIXPLUGINS, &CViewPattern::OnSelectPlugin)
//}}AFX_MSG_MAP
ON_WM_INITMENU()
ON_WM_RBUTTONDBLCLK()
ON_WM_RBUTTONUP()
END_MESSAGE_MAP()
static_assert(ModCommand::maxColumnValue <= 999, "Command range for ID_CHANGE_PCNOTE_PARAM is designed for 999");
const CSoundFile *CViewPattern::GetSoundFile() const { return (GetDocument() != nullptr) ? &GetDocument()->GetSoundFile() : nullptr; };
CSoundFile *CViewPattern::GetSoundFile() { return (GetDocument() != nullptr) ? &GetDocument()->GetSoundFile() : nullptr; };
const ModSequence &CViewPattern::Order() const { return GetSoundFile()->Order(); }
ModSequence &CViewPattern::Order() { return GetSoundFile()->Order(); }
CViewPattern::CViewPattern()
{
EnableActiveAccessibility();
m_Dib.Init(CMainFrame::bmpNotes);
UpdateColors();
m_PCNoteEditMemory = ModCommand::Empty();
m_octaveKeyMemory.fill(NOTE_NONE);
}
CViewPattern::~CViewPattern()
{
m_offScreenBitmap.DeleteObject();
m_offScreenDC.DeleteDC();
}
void CViewPattern::OnInitialUpdate()
{
CModScrollView::OnInitialUpdate();
EnableToolTips();
ChnVUMeters.fill(0);
OldVUMeters.fill(0);
m_previousNote.fill(NOTE_NONE);
m_splitActiveNoteChannel.fill(NOTE_CHANNEL_MAP_INVALID);
m_activeNoteChannel.fill(NOTE_CHANNEL_MAP_INVALID);
m_nPlayPat = PATTERNINDEX_INVALID;
m_nPlayRow = m_nNextPlayRow = 0;
m_nPlayTick = 0;
m_nTicksOnRow = 1;
m_nMidRow = 0;
m_nDragItem = {};
m_bInItemRect = false;
m_bContinueSearch = false;
m_Status = psShowPluginNames;
m_nXScroll = m_nYScroll = 0;
m_nPattern = 0;
m_nSpacing = 0;
m_nAccelChar = 0;
PatternFont::UpdateFont(m_hWnd);
UpdateSizes();
UpdateScrollSize();
SetCurrentPattern(0);
m_fallbackInstrument = 0;
m_nLastPlayedRow = 0;
m_nLastPlayedOrder = ORDERINDEX_INVALID;
m_prevChordNote = NOTE_NONE;
}
bool CViewPattern::SetCurrentPattern(PATTERNINDEX pat, ROWINDEX row)
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr)
return false;
if(pat == pSndFile->Order.GetIgnoreIndex() || pat == pSndFile->Order.GetInvalidPatIndex())
return false;
if(m_pEditWnd && m_pEditWnd->IsWindowVisible())
m_pEditWnd->ShowWindow(SW_HIDE);
m_nPattern = pat;
bool updateScroll = false;
if(pSndFile->Patterns.IsValidPat(pat))
{
if(row != ROWINDEX_INVALID && row != GetCurrentRow() && row < pSndFile->Patterns[m_nPattern].GetNumRows())
{
m_Cursor.SetRow(row);
updateScroll = true;
}
if(GetCurrentRow() >= pSndFile->Patterns[m_nPattern].GetNumRows())
{
m_Cursor.SetRow(0);
updateScroll = true;
}
}
SetSelToCursor();
UpdateSizes();
UpdateScrollSize();
UpdateIndicator();
if(m_bWholePatternFitsOnScreen)
SetScrollPos(SB_VERT, 0);
else if(updateScroll)
SetScrollPos(SB_VERT, (int)GetCurrentRow() * GetRowHeight());
UpdateScrollPos();
InvalidatePattern(true, true);
SendCtrlMessage(CTRLMSG_PATTERNCHANGED, m_nPattern);
return true;
}
// This should be used instead of consecutive calls to SetCurrentRow() then SetCurrentColumn().
bool CViewPattern::SetCursorPosition(const PatternCursor &cursor, bool wrap)
{
// Set row, but do not update scroll position yet
// as there is another position update on the way:
SetCurrentRow(cursor.GetRow(), wrap, false);
// Now set column and update scroll position:
SetCurrentColumn(cursor);
return true;
}
ROWINDEX CViewPattern::SetCurrentRow(ROWINDEX row, bool wrap, bool updateHorizontalScrollbar)
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidIndex(m_nPattern))
return ROWINDEX_INVALID;
if(wrap && pSndFile->Patterns[m_nPattern].GetNumRows())
{
const auto &order = Order();
if((int)row < 0)
{
if(m_Status[psKeyboardDragSelect | psMouseDragSelect])
{
row = 0;
} else if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL)
{
ORDERINDEX curOrder = GetCurrentOrder();
const ORDERINDEX prevOrd = order.GetPreviousOrderIgnoringSkips(curOrder);
if(prevOrd < curOrder && m_nPattern == order[curOrder])
{
const PATTERNINDEX nPrevPat = order[prevOrd];
if((nPrevPat < pSndFile->Patterns.Size()) && (pSndFile->Patterns[nPrevPat].GetNumRows()))
{
SetCurrentOrder(prevOrd);
if(SetCurrentPattern(nPrevPat))
return SetCurrentRow(pSndFile->Patterns[nPrevPat].GetNumRows() + (int)row);
}
}
row = 0;
} else if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_WRAP)
{
if((int)row < (int)0)
row += pSndFile->Patterns[m_nPattern].GetNumRows();
row %= pSndFile->Patterns[m_nPattern].GetNumRows();
}
} else //row >= 0
if(row >= pSndFile->Patterns[m_nPattern].GetNumRows())
{
if(m_Status[psKeyboardDragSelect | psMouseDragSelect])
{
row = pSndFile->Patterns[m_nPattern].GetNumRows() - 1;
} else if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL)
{
ORDERINDEX curOrder = GetCurrentOrder();
ORDERINDEX nextOrder = order.GetNextOrderIgnoringSkips(curOrder);
if(nextOrder > curOrder && m_nPattern == order[curOrder])
{
PATTERNINDEX nextPat = order[nextOrder];
if((nextPat < pSndFile->Patterns.Size()) && (pSndFile->Patterns[nextPat].GetNumRows()))
{
const ROWINDEX newRow = row - pSndFile->Patterns[m_nPattern].GetNumRows();
SetCurrentOrder(nextOrder);
if(SetCurrentPattern(nextPat))
return SetCurrentRow(newRow);
}
}
row = pSndFile->Patterns[m_nPattern].GetNumRows() - 1;
} else if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_WRAP)
{
row %= pSndFile->Patterns[m_nPattern].GetNumRows();
}
}
}
if(!(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL))
{
if(static_cast<int>(row) < 0)
row = 0;
if(row >= pSndFile->Patterns[m_nPattern].GetNumRows())
row = pSndFile->Patterns[m_nPattern].GetNumRows() - 1;
}
if((row >= pSndFile->Patterns[m_nPattern].GetNumRows()) || (!m_szCell.cy))
return false;
// Fix: If cursor isn't on screen move both scrollbars to make it visible
InvalidateRow();
m_Cursor.SetRow(row);
// Fix: Horizontal scrollbar pos screwed when selecting with mouse
UpdateScrollbarPositions(updateHorizontalScrollbar);
InvalidateRow();
PatternCursor selStart(m_Cursor);
if(m_Status[psKeyboardDragSelect | psMouseDragSelect] && !m_Status[psDragnDropEdit])
{
selStart.Set(m_StartSel);
}
SetCurSel(selStart, m_Cursor);
return row;
}
bool CViewPattern::SetCurrentColumn(CHANNELINDEX channel, PatternCursor::Columns column)
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr)
{
return false;
}
LimitMax(column, m_nDetailLevel);
m_Cursor.SetColumn(channel, column);
PatternCursor selStart(m_Cursor);
if(m_Status[psKeyboardDragSelect | psMouseDragSelect] && !m_Status[psDragnDropEdit])
{
selStart = m_StartSel;
}
SetCurSel(selStart, m_Cursor);
// Fix: If cursor isn't on screen move both scrollbars to make it visible
UpdateScrollbarPositions();
return true;
}
// Set document as modified and optionally update all pattern views.
void CViewPattern::SetModified(bool updateAllViews)
{
CModDoc *pModDoc = GetDocument();
if(pModDoc != nullptr)
{
pModDoc->SetModified();
pModDoc->UpdateAllViews(this, PatternHint(m_nPattern).Data(), updateAllViews ? nullptr : this);
}
CMainFrame::GetMainFrame()->NotifyAccessibilityUpdate(*this);
}
// Fix: If cursor isn't on screen move scrollbars to make it visible
// Fix: save pattern scrollbar position when switching to other tab
// Assume that m_nRow and m_dwCursor are valid
// When we switching to other tab the CViewPattern object is deleted
// and when switching back new one is created
bool CViewPattern::UpdateScrollbarPositions(bool updateHorizontalScrollbar)
{
// HACK - after new CViewPattern object created SetCurrentRow() and SetCurrentColumn() are called -
// just skip first two calls of UpdateScrollbarPositions() if pModDoc->GetOldPatternScrollbarsPos() is valid
CModDoc *pModDoc = GetDocument();
if(pModDoc)
{
CSize scroll = pModDoc->GetOldPatternScrollbarsPos();
if(scroll.cx >= 0)
{
OnScrollBy(scroll);
scroll.cx = -1;
pModDoc->SetOldPatternScrollbarsPos(scroll);
return true;
} else if(scroll.cx >= -1)
{
scroll.cx = -2;
pModDoc->SetOldPatternScrollbarsPos(scroll);
return true;
}
}
CSize scroll(0, 0);
UINT row = GetCurrentRow();
UINT yofs = GetYScrollPos();
CRect rect;
GetClientRect(&rect);
rect.top += m_szHeader.cy;
int numrows = (rect.bottom - rect.top - 1) / m_szCell.cy;
if(numrows < 1)
numrows = 1;
if(m_nMidRow)
{
if(row != yofs)
{
scroll.cy = (int)(row - yofs) * m_szCell.cy;
}
} else
{
if(row < yofs)
{
scroll.cy = (int)(row - yofs) * m_szCell.cy;
} else if(row > yofs + (UINT)numrows - 1)
{
scroll.cy = (int)(row - yofs - numrows + 1) * m_szCell.cy;
}
}
if(updateHorizontalScrollbar)
{
UINT xofs = GetXScrollPos();
const CHANNELINDEX nchn = GetCurrentChannel();
if(nchn < xofs)
{
scroll.cx = (int)(xofs - nchn) * m_szCell.cx;
scroll.cx *= -1;
} else if(nchn > xofs)
{
int maxcol = (rect.right - m_szHeader.cx) / m_szCell.cx;
if((nchn >= (xofs + maxcol)) && (maxcol >= 0))
{
scroll.cx = (int)(nchn - xofs - maxcol + 1) * m_szCell.cx;
}
}
}
if(scroll.cx != 0 || scroll.cy != 0)
{
OnScrollBy(scroll, TRUE);
}
return true;
}
DragItem CViewPattern::GetDragItem(CPoint point, RECT &outRect) const
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr)
return {};
CRect rcClient, rect, plugRect;
GetClientRect(&rcClient);
rect.SetRect(m_szHeader.cx, 0, m_szHeader.cx + GetChannelWidth(), m_szHeader.cy);
plugRect.SetRect(m_szHeader.cx, m_szHeader.cy - m_szPluginHeader.cy, m_szHeader.cx + GetChannelWidth(), m_szHeader.cy);
const auto xOffset = static_cast<CHANNELINDEX>(GetXScrollPos());
const CHANNELINDEX numChannels = pSndFile->GetNumChannels();
// Checking channel headers
if(m_Status[psShowPluginNames])
{
for(CHANNELINDEX n = xOffset; n < numChannels; n++)
{
if(plugRect.PtInRect(point))
{
outRect = plugRect;
return {DragItem::PluginName, n};
}
plugRect.OffsetRect(GetChannelWidth(), 0);
}
}
for(CHANNELINDEX n = xOffset; n < numChannels; n++)
{
if(rect.PtInRect(point))
{
outRect = rect;
return {DragItem::ChannelHeader, n};
}
rect.OffsetRect(GetChannelWidth(), 0);
}
if(pSndFile->Patterns.IsValidPat(m_nPattern) && (pSndFile->GetType() & (MOD_TYPE_XM | MOD_TYPE_IT | MOD_TYPE_MPT)))
{
// Clicking on upper-left corner with pattern number (for pattern properties)
rect.SetRect(0, 0, m_szHeader.cx, m_szHeader.cy);
if(rect.PtInRect(point))
{
outRect = rect;
return {DragItem::PatternHeader, 0};
}
}
return {};
}
// Drag a selection to position "cursor".
// If scrollHorizontal is true, the point's channel is ensured to be visible.
// Likewise, if scrollVertical is true, the point's row is ensured to be visible.
// If noMode if specified, the original selection points are not altered.
bool CViewPattern::DragToSel(const PatternCursor &cursor, bool scrollHorizontal, bool scrollVertical, bool noMove)
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidPat(m_nPattern))
return false;
CRect rect;
int yofs = GetYScrollPos(), xofs = GetXScrollPos();
int row, col;
if(!m_szCell.cy)
return false;
GetClientRect(&rect);
if(!noMove)
SetCurSel(m_StartSel, cursor);
if(!scrollHorizontal && !scrollVertical)
return true;
// Scroll to row
row = cursor.GetRow();
if(scrollVertical && row < (int)pSndFile->Patterns[m_nPattern].GetNumRows())
{
row += m_nMidRow;
rect.top += m_szHeader.cy;
int numrows = (rect.bottom - rect.top - 1) / m_szCell.cy;
if(numrows < 1)
numrows = 1;
if(row < yofs)
{
CSize sz;
sz.cx = 0;
sz.cy = (int)(row - yofs) * m_szCell.cy;
OnScrollBy(sz, TRUE);
} else if(row > yofs + numrows - 1)
{
CSize sz;
sz.cx = 0;
sz.cy = (int)(row - yofs - numrows + 1) * m_szCell.cy;
OnScrollBy(sz, TRUE);
}
}
// Scroll to column
col = cursor.GetChannel();
if(scrollHorizontal && col < (int)pSndFile->GetNumChannels())
{
int maxcol = (rect.right - m_szHeader.cx) - 4;
maxcol -= GetColumnOffset(cursor.GetColumnType());
maxcol /= GetChannelWidth();
if(col < xofs)
{
CSize size(-m_szCell.cx, 0);
if(!noMove)
size.cx = (col - xofs) * (int)m_szCell.cx;
OnScrollBy(size, TRUE);
} else if((col > xofs + maxcol) && (maxcol > 0))
{
CSize size(m_szCell.cx, 0);
if(!noMove)
size.cx = (col - maxcol + 1) * (int)m_szCell.cx;
OnScrollBy(size, TRUE);
}
}
UpdateWindow();
return true;
}
bool CViewPattern::SetPlayCursor(PATTERNINDEX pat, ROWINDEX row, uint32 tick)
{
PATTERNINDEX oldPat = m_nPlayPat;
ROWINDEX oldRow = m_nPlayRow;
uint32 oldTick = m_nPlayTick;
m_nPlayPat = pat;
m_nPlayRow = row;
m_nPlayTick = tick;
if(m_nPlayTick != oldTick && (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_SMOOTHSCROLL))
InvalidatePattern(true, true);
else if(oldPat == m_nPattern)
InvalidateRow(oldRow);
else if(m_nPlayPat == m_nPattern)
InvalidateRow(m_nPlayRow);
return true;
}
UINT CViewPattern::GetCurrentInstrument() const
{
return static_cast<UINT>(SendCtrlMessage(CTRLMSG_GETCURRENTINSTRUMENT));
}
bool CViewPattern::ShowEditWindow()
{
if(!m_pEditWnd)
{
m_pEditWnd = new CEditCommand(*GetSoundFile());
}
if(m_pEditWnd)
{
m_pEditWnd->ShowEditWindow(m_nPattern, m_Cursor, this);
return true;
}
return false;
}
bool CViewPattern::PrepareUndo(const PatternCursor &beginSel, const PatternCursor &endSel, const char *description)
{
CModDoc *pModDoc = GetDocument();
const CHANNELINDEX chnBegin = beginSel.GetChannel(), chnEnd = endSel.GetChannel();
const ROWINDEX rowBegin = beginSel.GetRow(), rowEnd = endSel.GetRow();
if((chnEnd < chnBegin) || (rowEnd < rowBegin) || pModDoc == nullptr)
return false;
return pModDoc->GetPatternUndo().PrepareUndo(m_nPattern, chnBegin, rowBegin, chnEnd - chnBegin + 1, rowEnd - rowBegin + 1, description);
}
BOOL CViewPattern::PreTranslateMessage(MSG *pMsg)
{
if(pMsg)
{
//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 = static_cast<UINT>(pMsg->wParam);
UINT nRepCnt = LOWORD(pMsg->lParam);
UINT nFlags = HIWORD(pMsg->lParam);
KeyEventType kT = ih->GetKeyEventType(nFlags);
InputTargetContext ctx = (InputTargetContext)(kCtxViewPatterns + 1 + m_Cursor.GetColumnType());
// If editing is disabled, preview notes no matter which column we are in
if(!IsEditingEnabled() && TrackerSettings::Instance().patternNoEditPopup)
ctx = kCtxViewPatternsNote;
if(ih->KeyEvent(ctx, nChar, nRepCnt, nFlags, kT) != kcNull)
{
return true; // Mapped to a command, no need to pass message on.
}
//HACK: fold kCtxViewPatternsFX and kCtxViewPatternsFXparam so that all commands of 1 are active in the other
else
{
if(ctx == kCtxViewPatternsFX)
{
if(ih->KeyEvent(kCtxViewPatternsFXparam, nChar, nRepCnt, nFlags, kT) != kcNull)
return true; // Mapped to a command, no need to pass message on.
} else if(ctx == kCtxViewPatternsFXparam)
{
if(ih->KeyEvent(kCtxViewPatternsFX, nChar, nRepCnt, nFlags, kT) != kcNull)
return true; // Mapped to a command, no need to pass message on.
} else if(ctx == kCtxViewPatternsIns)
{
// Do the same with instrument->note column
if(ih->KeyEvent(kCtxViewPatternsNote, nChar, nRepCnt, nFlags, kT) != kcNull)
return true; // Mapped to a command, no need to pass message on.
}
}
//end HACK.
// Handle Application (menu) key
if(pMsg->message == WM_KEYDOWN && nChar == VK_APPS)
{
OnRButtonDown(0, GetPointFromPosition(m_Cursor));
}
} else if(pMsg->message == WM_MBUTTONDOWN)
{
// Open quick channel properties dialog if we're middle-clicking a channel header.
CPoint point(GET_X_LPARAM(pMsg->lParam), GET_Y_LPARAM(pMsg->lParam));
if(point.y < m_szHeader.cy - m_szPluginHeader.cy)
{
PatternCursor cursor = GetPositionFromPoint(point);
if(cursor.GetChannel() < GetDocument()->GetNumChannels())
{
ClientToScreen(&point);
m_quickChannelProperties.Show(GetDocument(), cursor.GetChannel(), point);
return true;
}
}
}
}
return CModScrollView::PreTranslateMessage(pMsg);
}
////////////////////////////////////////////////////////////////////////
// CViewPattern message handlers
void CViewPattern::OnDestroy()
{
// Fix: save pattern scrollbar position when switching to other tab
// When we switching to other tab the CViewPattern object is deleted
CModDoc *pModDoc = GetDocument();
if(pModDoc)
{
pModDoc->SetOldPatternScrollbarsPos(CSize(m_nXScroll * m_szCell.cx, m_nYScroll * m_szCell.cy));
}
if(m_pEffectVis)
{
m_pEffectVis->DoClose();
m_pEffectVis = nullptr;
}
if(m_pEditWnd)
{
m_pEditWnd->DestroyWindow();
delete m_pEditWnd;
m_pEditWnd = NULL;
}
CModScrollView::OnDestroy();
}
void CViewPattern::OnSetFocus(CWnd *pOldWnd)
{
CScrollView::OnSetFocus(pOldWnd);
m_Status.set(psFocussed);
InvalidateRow();
CModDoc *pModDoc = GetDocument();
if(pModDoc)
{
pModDoc->SetNotifications(Notification::Position | Notification::VUMeters);
pModDoc->SetFollowWnd(m_hWnd);
UpdateIndicator();
}
}
void CViewPattern::OnKillFocus(CWnd *pNewWnd)
{
CScrollView::OnKillFocus(pNewWnd);
m_Status.reset(psKeyboardDragSelect | psCtrlDragSelect | psFocussed);
InvalidateRow();
}
void CViewPattern::OnGrowSelection()
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidPat(m_nPattern))
{
return;
}
BeginWaitCursor();
m_Selection.Sanitize(pSndFile->Patterns[m_nPattern].GetNumRows(), pSndFile->GetNumChannels());
const PatternCursor startSel = m_Selection.GetUpperLeft();
const PatternCursor endSel = m_Selection.GetLowerRight();
PrepareUndo(startSel, PatternCursor(pSndFile->Patterns[m_nPattern].GetNumRows(), endSel), "Grow Selection");
const ROWINDEX finalDest = m_Selection.GetStartRow() + (m_Selection.GetNumRows() - 1) * 2;
for(int row = finalDest; row > (int)startSel.GetRow(); row -= 2)
{
if(ROWINDEX(row) >= pSndFile->Patterns[m_nPattern].GetNumRows())
{
continue;
}
int offset = row - startSel.GetRow();
for(CHANNELINDEX chn = startSel.GetChannel(); chn <= endSel.GetChannel(); chn++)
{
for(int i = PatternCursor::firstColumn; i <= PatternCursor::lastColumn; i++)
{
PatternCursor cell(row, chn, static_cast<PatternCursor::Columns>(i));
if(!m_Selection.ContainsHorizontal(cell))
{
// We might have to skip the first / last few entries.
continue;
}
ModCommand *dest = pSndFile->Patterns[m_nPattern].GetpModCommand(row, chn);
ModCommand *src = pSndFile->Patterns[m_nPattern].GetpModCommand(row - offset / 2, chn);
ModCommand *blank = pSndFile->Patterns[m_nPattern].GetpModCommand(row - 1, chn); // Row "in between"
switch(i)
{
case PatternCursor::noteColumn:
dest->note = src->note;
blank->note = NOTE_NONE;
break;
case PatternCursor::instrColumn:
dest->instr = src->instr;
blank->instr = 0;
break;
case PatternCursor::volumeColumn:
dest->volcmd = src->volcmd;
blank->volcmd = VOLCMD_NONE;
dest->vol = src->vol;
blank->vol = 0;
break;
case PatternCursor::effectColumn:
dest->command = src->command;
blank->command = CMD_NONE;
break;
case PatternCursor::paramColumn:
dest->param = src->param;
blank->param = 0;
break;
}
}
}
}
// Adjust selection
m_Selection = PatternRect(startSel, PatternCursor(std::min(finalDest, static_cast<ROWINDEX>(pSndFile->Patterns[m_nPattern].GetNumRows() - 1)), endSel));
InvalidatePattern();
SetModified();
EndWaitCursor();
SetFocus();
}
void CViewPattern::OnShrinkSelection()
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidPat(m_nPattern))
{
return;
}
BeginWaitCursor();
m_Selection.Sanitize(pSndFile->Patterns[m_nPattern].GetNumRows(), pSndFile->GetNumChannels());
const PatternCursor startSel = m_Selection.GetUpperLeft();
const PatternCursor endSel = m_Selection.GetLowerRight();
PrepareUndo(startSel, endSel, "Shrink Selection");
const ROWINDEX finalDest = m_Selection.GetStartRow() + (m_Selection.GetNumRows() - 1) / 2;
for(ROWINDEX row = startSel.GetRow(); row <= endSel.GetRow(); row++)
{
const ROWINDEX offset = row - startSel.GetRow();
const ROWINDEX srcRow = startSel.GetRow() + (offset * 2);
for(CHANNELINDEX chn = startSel.GetChannel(); chn <= endSel.GetChannel(); chn++)
{
ModCommand *dest = pSndFile->Patterns[m_nPattern].GetpModCommand(row, chn);
ModCommand src;
if(row <= finalDest)
{
// Normal shrink operation
src = *pSndFile->Patterns[m_nPattern].GetpModCommand(srcRow, chn);
// If source command is empty, try next source row (so we don't lose all the stuff that's on odd rows).
if(srcRow < pSndFile->Patterns[m_nPattern].GetNumRows() - 1)
{
const ModCommand &srcNext = *pSndFile->Patterns[m_nPattern].GetpModCommand(srcRow + 1, chn);
if(src.note == NOTE_NONE)
src.note = srcNext.note;
if(src.instr == 0)
src.instr = srcNext.instr;
if(src.volcmd == VOLCMD_NONE)
{
src.volcmd = srcNext.volcmd;
src.vol = srcNext.vol;
}
if(src.command == CMD_NONE)
{
src.command = srcNext.command;
src.param = srcNext.param;
}
}
} else
{
// Clean up rows that are now supposed to be empty.
src = ModCommand::Empty();
}
for(int i = PatternCursor::firstColumn; i <= PatternCursor::lastColumn; i++)
{
PatternCursor cell(row, chn, static_cast<PatternCursor::Columns>(i));
if(!m_Selection.ContainsHorizontal(cell))
{
// We might have to skip the first / last few entries.
continue;
}
switch(i)
{
case PatternCursor::noteColumn:
dest->note = src.note;
break;
case PatternCursor::instrColumn:
dest->instr = src.instr;
break;
case PatternCursor::volumeColumn:
dest->vol = src.vol;
dest->volcmd = src.volcmd;
break;
case PatternCursor::effectColumn:
dest->command = src.command;
break;
case PatternCursor::paramColumn:
dest->param = src.param;
break;
}
}
}
}
// Adjust selection
m_Selection = PatternRect(startSel, PatternCursor(std::min(finalDest, static_cast<ROWINDEX>(pSndFile->Patterns[m_nPattern].GetNumRows() - 1)), endSel));
InvalidatePattern();
SetModified();
EndWaitCursor();
SetFocus();
}
void CViewPattern::OnClearSelectionFromMenu()
{
OnClearSelection();
}
void CViewPattern::OnClearSelection(bool ITStyle, RowMask rm) //Default RowMask: all elements enabled
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidPat(m_nPattern) || !IsEditingEnabled_bmsg())
{
return;
}
BeginWaitCursor();
// If selection ends to a note column, in ITStyle extending it to instrument column since the instrument data is
// removed with note data.
if(ITStyle && m_Selection.GetEndColumn() == PatternCursor::noteColumn)
{
PatternCursor lower(m_Selection.GetLowerRight());
lower.Move(0, 0, 1);
m_Selection = PatternRect(m_Selection.GetUpperLeft(), lower);
}
m_Selection.Sanitize(pSndFile->Patterns[m_nPattern].GetNumRows(), pSndFile->GetNumChannels());
PrepareUndo(m_Selection, "Clear Selection");
ApplyToSelection([&] (ModCommand &m, ROWINDEX row, CHANNELINDEX chn)
{
for(int i = PatternCursor::firstColumn; i <= PatternCursor::lastColumn; i++)
{
PatternCursor cell(row, chn, static_cast<PatternCursor::Columns>(i));
if(!m_Selection.ContainsHorizontal(cell))
{
// We might have to skip the first / last few entries.
continue;
}
switch(i)
{
case PatternCursor::noteColumn: // Clear note
if(rm.note)
{
if(m.IsPcNote())
{ // Clear whole cell if clearing PC note
m.Clear();
} else
{
m.note = NOTE_NONE;
if(ITStyle)
m.instr = 0;
}
}
break;
case PatternCursor::instrColumn: // Clear instrument
if(rm.instrument)
{
m.instr = 0;
}
break;
case PatternCursor::volumeColumn: // Clear volume
if(rm.volume)
{
m.volcmd = VOLCMD_NONE;
m.vol = 0;
}
break;
case PatternCursor::effectColumn: // Clear Command
if(rm.command)
{
m.command = CMD_NONE;
if(m.IsPcNote())
{
m.SetValueEffectCol(0);
}
}
break;
case PatternCursor::paramColumn: // Clear Command Param
if(rm.parameter)
{
m.param = 0;
if(m.IsPcNote())
{
m.SetValueEffectCol(0);
if(cell.CompareColumn(m_Selection.GetUpperLeft()) == 0)
{
// If this is the first selected column, update effect column char as well
PatternCursor upper(m_Selection.GetUpperLeft());
upper.Move(0, 0, -1);
m_Selection = PatternRect(upper, m_Selection.GetLowerRight());
}
}
}
break;
}
}
});
// Expand invalidation to the whole column. Needed for:
// - Last column is the effect character (parameter needs to be invalidated, too
// - PC Notes
// - Default volume display is enabled.
PatternCursor endCursor(m_Selection.GetEndRow(), m_Selection.GetEndChannel() + 1);
InvalidateArea(m_Selection.GetUpperLeft(), endCursor);
SetModified();
EndWaitCursor();
SetFocus();
}
void CViewPattern::OnEditCut()
{
OnEditCopy();
OnClearSelection(false);
}
void CViewPattern::OnEditCopy()
{
CModDoc *pModDoc = GetDocument();
if(pModDoc)
{
CopyPattern(m_nPattern, m_Selection);
SetFocus();
}
}
void CViewPattern::StartRecordGroupDragging(const DragItem source)
{
// Drag-select record channels
const auto *modDoc = GetDocument();
if(modDoc == nullptr)
return;
m_initialDragRecordStatus.resize(modDoc->GetNumChannels());
for(CHANNELINDEX chn = 0; chn < modDoc->GetNumChannels(); chn++)
{
m_initialDragRecordStatus[chn] = modDoc->GetChannelRecordGroup(chn);
}
m_Status.reset(psDragging);
m_nDropItem = m_nDragItem = source;
}
void CViewPattern::OnLButtonDown(UINT nFlags, CPoint point)
{
const auto *modDoc = GetDocument();
if(modDoc == nullptr)
return;
const auto &sndFile = modDoc->GetSoundFile();
SetFocus();
m_nDropItem = m_nDragItem = GetDragItem(point, m_rcDragItem);
m_Status.set(psDragging);
m_bInItemRect = true;
m_Status.reset(psShiftDragging);
PatternCursor pointCursor(GetPositionFromPoint(point));
SetCapture();
if(point.x >= m_szHeader.cx && point.y <= m_szHeader.cy - m_szPluginHeader.cy)
{
// Click on channel header
if(nFlags & MK_CONTROL)
TogglePendingMute(pointCursor.GetChannel());
if(nFlags & MK_SHIFT)
{
// Drag-select record channels
StartRecordGroupDragging(m_nDragItem);
}
} else if(point.x >= m_szHeader.cx && point.y > m_szHeader.cy)
{
// Click on pattern data
if(IsLiveRecord() && (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_NOFOLLOWONCLICK))
{
SendCtrlMessage(CTRLMSG_PAT_FOLLOWSONG, 0);
}
if(CMainFrame::GetInputHandler()->SelectionPressed()
&& (m_Status[psShiftSelect]
|| m_Selection.GetUpperLeft() == m_Selection.GetLowerRight()
|| !m_Selection.Contains(pointCursor)))
{
// Shift pressed -> set 2nd selection point
// This behaviour is only used if:
// * Shift-click has previously been used since the shift key has been pressed down (psShiftSelect flag is set),
// * No selection has been made yet, or
// * Shift-clicking outside the current selection.
// This is necessary so that selections can still be moved properly while the shift button is pressed (for copy-move).
DragToSel(pointCursor, true, true);
m_Status.set(psShiftSelect);
} else
{
// Set first selection point
m_StartSel = pointCursor;
if(m_StartSel.GetChannel() < sndFile.GetNumChannels())
{
m_Status.set(psMouseDragSelect);
if(m_Status[psCtrlDragSelect])
{
SetCurSel(m_StartSel);
}
if((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_DRAGNDROPEDIT)
&& ((m_Selection.GetUpperLeft() != m_Selection.GetLowerRight()) || m_Status[psCtrlDragSelect])
&& m_Selection.Contains(m_StartSel))
{
m_Status.set(psDragnDropEdit);
} else if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CENTERROW)
{
SetCurSel(m_StartSel);
} else
{
// Fix: Horizontal scrollbar pos screwed when selecting with mouse
SetCursorPosition(m_StartSel);
}
}
}
} else if(point.x < m_szHeader.cx && point.y > m_szHeader.cy)
{
// Mark row number => mark whole row (start)
InvalidateSelection();
if(pointCursor.GetRow() < sndFile.Patterns[m_nPattern].GetNumRows())
{
m_StartSel.Set(pointCursor.GetRow(), 0);
SetCurSel(m_StartSel, PatternCursor(pointCursor.GetRow(), sndFile.GetNumChannels() - 1, PatternCursor::lastColumn));
m_Status.set(psRowSelection);
}
}
if(m_nDragItem.IsValid())
{
InvalidateRect(&m_rcDragItem, FALSE);
UpdateWindow();
}
}
void CViewPattern::OnLButtonDblClk(UINT uFlags, CPoint point)
{
PatternCursor cursor = GetPositionFromPoint(point);
if(cursor == m_Cursor && point.y >= m_szHeader.cy)
{
// Double-click pattern cell: Select whole column or show cell properties.
if((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_DBLCLICKSELECT))
{
OnSelectCurrentChannel();
m_Status.set(psChannelSelection | psDragging);
return;
} else
{
if(ShowEditWindow())
return;
}
}
OnLButtonDown(uFlags, point);
}
void CViewPattern::OnLButtonUp(UINT nFlags, CPoint point)
{
CModDoc *modDoc = GetDocument();
if(modDoc == nullptr)
return;
const auto dragType = m_nDragItem.Type();
const bool wasDraggingRecordGroup = IsDraggingRecordGroup();
const bool itemSelected = m_bInItemRect || (dragType == DragItem::ChannelHeader);
m_bInItemRect = false;
ResetRecordGroupDragging();
ReleaseCapture();
m_Status.reset(psMouseDragSelect | psRowSelection | psChannelSelection | psDragging);
// Drag & Drop Editing
if(m_Status[psDragnDropEdit])
{
if(m_Status[psDragnDropping])
{
OnDrawDragSel();
m_Status.reset(psDragnDropping);
OnDropSelection();
}
if(GetPositionFromPoint(point) == m_StartSel)
{
SetCursorPosition(m_StartSel);
}
SetCursor(CMainFrame::curArrow);
m_Status.reset(psDragnDropEdit);
}
if(dragType != DragItem::ChannelHeader
&& dragType != DragItem::PatternHeader
&& dragType != DragItem::PluginName)
{
if((m_nMidRow) && (m_Selection.GetUpperLeft() == m_Selection.GetLowerRight()))
{
// Fix: Horizontal scrollbar pos screwed when selecting with mouse
SetCursorPosition(m_Selection.GetUpperLeft());
//UpdateIndicator();
}
}
if(!itemSelected || !m_nDragItem.IsValid())
return;
InvalidateRect(&m_rcDragItem, FALSE);
const CHANNELINDEX sourceChn = static_cast<CHANNELINDEX>(m_nDragItem.Value());
const CHANNELINDEX targetChn = m_nDropItem.IsValid() ? static_cast<CHANNELINDEX>(m_nDropItem.Value()) : CHANNELINDEX_INVALID;
switch(m_nDragItem.Type())
{
case DragItem::ChannelHeader:
if(sourceChn == targetChn && targetChn < modDoc->GetNumChannels())
{
// Just clicked a channel header...
if(nFlags & MK_SHIFT)
{
// Toggle record state
modDoc->ToggleChannelRecordGroup(sourceChn, RecordGroup::Group1);
InvalidateChannelsHeaders(sourceChn);
} else if(CMainFrame::GetInputHandler()->AltPressed())
{
// Solo / Unsolo
OnSoloChannel(sourceChn);
} else if(!(nFlags & MK_CONTROL))
{
// Mute / Unmute
OnMuteChannel(sourceChn);
}
} else if(!wasDraggingRecordGroup && targetChn < modDoc->GetNumChannels() && m_nDropItem.Type() == DragItem::ChannelHeader)
{
// Dragged to other channel header => move or copy channel
InvalidateRect(&m_rcDropItem, FALSE);
const bool duplicate = (nFlags & MK_SHIFT) != 0;
DragChannel(sourceChn, targetChn, 1, duplicate);
}
break;
case DragItem::PatternHeader:
OnPatternProperties();
break;
case DragItem::PluginName:
if(sourceChn < MAX_BASECHANNELS)
TogglePluginEditor(sourceChn);
break;
}
m_nDropItem = {};
}
void CViewPattern::DragChannel(CHANNELINDEX source, CHANNELINDEX target, CHANNELINDEX numChannels, bool duplicate)
{
auto modDoc = GetDocument();
const CHANNELINDEX newChannels = modDoc->GetNumChannels() + (duplicate ? numChannels : 0);
std::vector<CHANNELINDEX> channels(newChannels, 0);
bool modified = duplicate;
for(CHANNELINDEX chn = 0, fromChn = 0; chn < newChannels; chn++)
{
if(chn >= target && chn < target + numChannels)
{
channels[chn] = source + chn - target;
} else
{
if(fromChn == source && !duplicate) // Don't want the source channels twice if we're just moving
{
fromChn += numChannels;
}
channels[chn] = fromChn++;
}
if(channels[chn] != chn)
{
modified = true;
}
}
if(modified && modDoc->ReArrangeChannels(channels) != CHANNELINDEX_INVALID)
{
modDoc->UpdateAllViews(this, GeneralHint().Channels().ModType(), this);
if(duplicate)
{
// Number of channels changed: Update channel headers and other information.
SetCurrentPattern(m_nPattern);
}
if(!duplicate)
{
const auto oldSel = m_Selection;
if(auto chn = m_Cursor.GetChannel(); (chn >= source && chn < source + numChannels))
SetCurrentColumn(target + chn - source, m_Cursor.GetColumnType());
if(oldSel.GetStartChannel() >= source && oldSel.GetEndChannel() < source + numChannels)
{
const auto diff = static_cast<int>(target) - source;
auto upperLeft = oldSel.GetUpperLeft(), lowerRight = oldSel.GetLowerRight();
upperLeft.Move(0, diff, 0);
lowerRight.Move(0, diff, 0);
SetCurSel(upperLeft, lowerRight);
}
}
InvalidatePattern(true, false);
SetModified(false);
}
}
void CViewPattern::ShowPatternProperties(PATTERNINDEX pat)
{
CModDoc *pModDoc = GetDocument();
if(pat == PATTERNINDEX_INVALID)
pat = m_nPattern;
if(pModDoc && pModDoc->GetSoundFile().Patterns.IsValidPat(pat))
{
CPatternPropertiesDlg dlg(*pModDoc, pat, this);
if(dlg.DoModal() == IDOK)
{
UpdateScrollSize();
InvalidatePattern(true, true);
SanitizeCursor();
pModDoc->UpdateAllViews(this, PatternHint(pat).Data(), this);
}
}
}
void CViewPattern::OnRButtonDown(UINT flags, CPoint pt)
{
CModDoc *modDoc = GetDocument();
HMENU hMenu;
// Too far left to get a ctx menu:
if(!modDoc || pt.x < m_szHeader.cx)
{
return;
}
// Handle drag n drop
if(m_Status[psDragnDropEdit])
{
if(m_Status[psDragnDropping])
{
OnDrawDragSel();
m_Status.reset(psDragnDropping);
}
m_Status.reset(psDragnDropEdit | psMouseDragSelect);
if(m_Status[psDragging])
{
m_Status.reset(psDragging);
m_bInItemRect = false;
ReleaseCapture();
}
SetCursor(CMainFrame::curArrow);
return;
}
if((hMenu = ::CreatePopupMenu()) == NULL)
{
return;
}
CSoundFile &sndFile = modDoc->GetSoundFile();
m_MenuCursor = GetPositionFromPoint(pt);
// Right-click outside single-point selection? Reposition cursor to the new location
if(!m_Selection.Contains(m_MenuCursor) && m_Selection.GetUpperLeft() == m_Selection.GetLowerRight())
{
if(pt.y > m_szHeader.cy)
{
//ensure we're not clicking header
// Fix: Horizontal scrollbar pos screwed when selecting with mouse
SetCursorPosition(m_MenuCursor);
}
}
const CHANNELINDEX nChn = m_MenuCursor.GetChannel();
const bool inChannelHeader = (pt.y < m_szHeader.cy);
if((flags & MK_CONTROL) && nChn < sndFile.GetNumChannels() && inChannelHeader)
{
// Ctrl+Right-Click: Open quick channel properties.
ClientToScreen(&pt);
m_quickChannelProperties.Show(GetDocument(), nChn, pt);
} else if((flags & MK_SHIFT) && inChannelHeader)
{
// Drag-select record channels
StartRecordGroupDragging(GetDragItem(pt, m_rcDragItem));
} else if(nChn < sndFile.GetNumChannels() && sndFile.Patterns.IsValidPat(m_nPattern) && !(flags & (MK_CONTROL | MK_SHIFT)))
{
CInputHandler *ih = CMainFrame::GetInputHandler();
//------ Plugin Header Menu --------- :
if(m_Status[psShowPluginNames] &&
inChannelHeader && (pt.y > m_szHeader.cy - m_szPluginHeader.cy))
{
BuildPluginCtxMenu(hMenu, nChn, sndFile);
}
//------ Channel Header Menu ---------- :
else if(inChannelHeader)
{
if(ih->ShiftPressed())
{
//Don't bring up menu if shift is pressed, else we won't get button up msg.
} else
{
if(BuildSoloMuteCtxMenu(hMenu, ih, nChn, sndFile))
AppendMenu(hMenu, MF_SEPARATOR, 0, _T(""));
BuildRecordCtxMenu(hMenu, ih, nChn);
BuildChannelControlCtxMenu(hMenu, ih);
}
}
//------ Standard Menu ---------- :
else if((pt.x >= m_szHeader.cx) && (pt.y >= m_szHeader.cy))
{
// When combining menus, use bitwise ORs to avoid shortcuts
if(BuildSelectionCtxMenu(hMenu, ih))
AppendMenu(hMenu, MF_SEPARATOR, 0, _T(""));
if(BuildEditCtxMenu(hMenu, ih, modDoc))
AppendMenu(hMenu, MF_SEPARATOR, 0, _T(""));
if(BuildInterpolationCtxMenu(hMenu, ih)
| BuildTransposeCtxMenu(hMenu, ih))
AppendMenu(hMenu, MF_SEPARATOR, 0, _T(""));
if(BuildVisFXCtxMenu(hMenu, ih)
| BuildAmplifyCtxMenu(hMenu, ih)
| BuildSetInstCtxMenu(hMenu, ih))
AppendMenu(hMenu, MF_SEPARATOR, 0, _T(""));
if(BuildPCNoteCtxMenu(hMenu, ih))
AppendMenu(hMenu, MF_SEPARATOR, 0, _T(""));
if(BuildGrowShrinkCtxMenu(hMenu, ih))
AppendMenu(hMenu, MF_SEPARATOR, 0, _T(""));
if(BuildMiscCtxMenu(hMenu, ih))
AppendMenu(hMenu, MF_SEPARATOR, 0, _T(""));
if(BuildRowInsDelCtxMenu(hMenu, ih))
AppendMenu(hMenu, MF_SEPARATOR, 0, _T(""));
CString s = _T("&Quantize ");
if(TrackerSettings::Instance().recordQuantizeRows != 0)
{
uint32 rows = TrackerSettings::Instance().recordQuantizeRows.Get();
s += MPT_CFORMAT("(Currently: {} Row{})")(rows, CString(rows == 1 ? _T("") : _T("s")));
} else
{
s += _T("Settings...");
}
AppendMenu(hMenu, MF_STRING | (TrackerSettings::Instance().recordQuantizeRows != 0 ? MF_CHECKED : 0), ID_SETQUANTIZE, ih->GetKeyTextFromCommand(kcQuantizeSettings, s));
}
ClientToScreen(&pt);
::TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, 0, m_hWnd, NULL);
} else if(nChn >= sndFile.GetNumChannels() && sndFile.GetNumChannels() < sndFile.GetModSpecifications().channelsMax && !(flags & (MK_CONTROL | MK_SHIFT)))
{
// Click outside of pattern: Offer easy way to add more channels
m_MenuCursor.Set(0, sndFile.GetNumChannels() - 1);
AppendMenu(hMenu, MF_STRING, ID_PATTERN_ADDCHANNEL_AFTER, _T("&Add Channel"));
ClientToScreen(&pt);
::TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, 0, m_hWnd, NULL);
}
::DestroyMenu(hMenu);
}
void CViewPattern::OnRButtonUp(UINT nFlags, CPoint point)
{
CModDoc *pModDoc = GetDocument();
if(!pModDoc)
return;
ResetRecordGroupDragging();
const CHANNELINDEX sourceChn = static_cast<CHANNELINDEX>(m_nDragItem.Value());
const CHANNELINDEX targetChn = m_nDropItem.IsValid() ? static_cast<CHANNELINDEX>(m_nDropItem.Value()) : CHANNELINDEX_INVALID;
switch(m_nDragItem.Type())
{
case DragItem::ChannelHeader:
if(nFlags & MK_SHIFT)
{
if(sourceChn < MAX_BASECHANNELS && sourceChn == targetChn)
{
pModDoc->ToggleChannelRecordGroup(sourceChn, RecordGroup::Group2);
InvalidateChannelsHeaders(sourceChn);
}
}
break;
}
CModScrollView::OnRButtonUp(nFlags, point);
}
BOOL CViewPattern::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
if(nFlags & MK_CONTROL)
{
// Ctrl + mouse wheel: Increment / decrement values
DataEntry(zDelta > 0, (nFlags & MK_SHIFT) == MK_SHIFT);
return TRUE;
}
if(IsLiveRecord() && !m_Status[psDragActive])
{
// During live playback with "follow song" enabled, the mouse wheel can be used to jump forwards and backwards.
CursorJump(-mpt::signum(zDelta), false);
return TRUE;
}
return CModScrollView::OnMouseWheel(nFlags, zDelta, pt);
}
void CViewPattern::OnXButtonUp(UINT nFlags, UINT nButton, CPoint point)
{
if(nButton == XBUTTON1)
OnPrevOrder();
else if(nButton == XBUTTON2)
OnNextOrder();
CModScrollView::OnXButtonUp(nFlags, nButton, point);
}
void CViewPattern::OnMouseMove(UINT nFlags, CPoint point)
{
CModScrollView::OnMouseMove(nFlags, point);
const bool isDraggingRecordGroup = IsDraggingRecordGroup();
if(!m_Status[psDragging] && !isDraggingRecordGroup)
return;
// Drag&Drop actions
if(m_nDragItem.IsValid())
{
const CRect oldDropRect = m_rcDropItem;
const auto oldDropItem = m_nDropItem;
if(isDraggingRecordGroup)
{
// When drag-selecting record channels, ignore y position
point.y = m_rcDragItem.top;
}
m_Status.set(psShiftDragging, (nFlags & MK_SHIFT) != 0);
m_nDropItem = GetDragItem(point, m_rcDropItem);
const bool b = (m_nDropItem == m_nDragItem);
const bool dragChannel = m_nDragItem.Type() == DragItem::ChannelHeader;
if(b != m_bInItemRect || (m_nDropItem != oldDropItem && dragChannel))
{
m_bInItemRect = b;
InvalidateRect(&m_rcDragItem, FALSE);
// Drag-select record channels
if(isDraggingRecordGroup && m_nDropItem.Type() == DragItem::ChannelHeader)
{
auto modDoc = GetDocument();
auto startChn = static_cast<CHANNELINDEX>(m_nDragItem.Value());
auto endChn = static_cast<CHANNELINDEX>(m_nDropItem.Value());
RecordGroup setRecord = RecordGroup::NoGroup;
if(m_initialDragRecordStatus[startChn] != RecordGroup::Group1 && (nFlags & MK_LBUTTON))
setRecord = RecordGroup::Group1;
else if (m_initialDragRecordStatus[startChn] != RecordGroup::Group2 && (nFlags & MK_RBUTTON))
setRecord = RecordGroup::Group2;
if(startChn > endChn)
std::swap(startChn, endChn);
CHANNELINDEX numChannels = std::min(modDoc->GetNumChannels(), static_cast<CHANNELINDEX>(m_initialDragRecordStatus.size()));
for(CHANNELINDEX chn = 0; chn < numChannels; chn++)
{
auto oldState = modDoc->GetChannelRecordGroup(chn);
if(chn >= startChn && chn <= endChn)
GetDocument()->SetChannelRecordGroup(chn, setRecord);
else
GetDocument()->SetChannelRecordGroup(chn, m_initialDragRecordStatus[chn]);
if(oldState != modDoc->GetChannelRecordGroup(chn))
InvalidateChannelsHeaders(chn);
}
} else
{
// Dragging around channel headers? Update move indicator...
if(m_nDropItem.Type() == DragItem::ChannelHeader)
InvalidateRect(&m_rcDropItem, FALSE);
if(oldDropItem.Type() == DragItem::ChannelHeader)
InvalidateRect(&oldDropRect, FALSE);
}
UpdateWindow();
}
}
if(m_Status[psChannelSelection])
{
// Double-clicked a pattern cell to select whole channel.
// Continue dragging to select more channels.
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile->Patterns.IsValidPat(m_nPattern))
{
const ROWINDEX lastRow = pSndFile->Patterns[m_nPattern].GetNumRows() - 1;
CHANNELINDEX startChannel = m_Cursor.GetChannel();
CHANNELINDEX endChannel = GetPositionFromPoint(point).GetChannel();
m_StartSel = PatternCursor(0, startChannel, (startChannel <= endChannel ? PatternCursor::firstColumn : PatternCursor::lastColumn));
PatternCursor endSel = PatternCursor(lastRow, endChannel, (startChannel <= endChannel ? PatternCursor::lastColumn : PatternCursor::firstColumn));
DragToSel(endSel, true, false, false);
}
} else if(m_Status[psRowSelection] && point.y > m_szHeader.cy)
{
// Mark row number => mark whole row (continue)
InvalidateSelection();
PatternCursor cursor(GetPositionFromPoint(point));
cursor.SetColumn(GetDocument()->GetNumChannels() - 1, PatternCursor::lastColumn);
DragToSel(cursor, false, true, false);
} else if(m_Status[psMouseDragSelect])
{
PatternCursor cursor(GetPositionFromPoint(point));
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr && m_nPattern < pSndFile->Patterns.Size())
{
ROWINDEX row = cursor.GetRow();
LimitMax(row, pSndFile->Patterns[m_nPattern].GetNumRows() - 1);
cursor.SetRow(row);
}
// Drag & Drop editing
if(m_Status[psDragnDropEdit])
{
const bool moved = m_DragPos.GetChannel() != cursor.GetChannel() || m_DragPos.GetRow() != cursor.GetRow();
if(!m_Status[psDragnDropping])
{
SetCursor(CMainFrame::curDragging);
}
if(!m_Status[psDragnDropping] || moved)
{
if(m_Status[psDragnDropping])
OnDrawDragSel();
m_Status.reset(psDragnDropping);
DragToSel(cursor, true, true, true);
m_DragPos = cursor;
m_Status.set(psDragnDropping);
OnDrawDragSel();
}
} else if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CENTERROW)
{
// Default: selection
DragToSel(cursor, true, true);
} else
{
// Fix: Horizontal scrollbar pos screwed when selecting with mouse
SetCursorPosition(cursor);
}
}
}
void CViewPattern::OnEditSelectAll()
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr && pSndFile->Patterns.IsValidPat(m_nPattern))
{
SetCurSel(PatternCursor(0), PatternCursor(pSndFile->Patterns[m_nPattern].GetNumRows() - 1, pSndFile->GetNumChannels() - 1, PatternCursor::lastColumn));
}
}
void CViewPattern::OnEditSelectChannel()
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr && pSndFile->Patterns.IsValidPat(m_nPattern))
{
SetCurSel(PatternCursor(0, m_MenuCursor.GetChannel()), PatternCursor(pSndFile->Patterns[m_nPattern].GetNumRows() - 1, m_MenuCursor.GetChannel(), PatternCursor::lastColumn));
}
}
void CViewPattern::OnSelectCurrentChannel()
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr && pSndFile->Patterns.IsValidPat(m_nPattern))
{
PatternCursor beginSel(0, GetCurrentChannel());
PatternCursor endSel(pSndFile->Patterns[m_nPattern].GetNumRows() - 1, GetCurrentChannel(), PatternCursor::lastColumn);
// If column is already selected, select the current pattern
if((beginSel == m_Selection.GetUpperLeft()) && (endSel == m_Selection.GetLowerRight()))
{
beginSel.Set(0, 0);
endSel.Set(pSndFile->Patterns[m_nPattern].GetNumRows() - 1, pSndFile->GetNumChannels() - 1, PatternCursor::lastColumn);
}
SetCurSel(beginSel, endSel);
}
}
void CViewPattern::OnSelectCurrentColumn()
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr && pSndFile->Patterns.IsValidPat(m_nPattern))
{
SetCurSel(PatternCursor(0, m_Cursor), PatternCursor(pSndFile->Patterns[m_nPattern].GetNumRows() - 1, m_Cursor));
}
}
void CViewPattern::OnChannelReset()
{
ResetChannel(m_MenuCursor.GetChannel());
}
// Reset all channel variables
void CViewPattern::ResetChannel(CHANNELINDEX chn)
{
CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr)
return;
CSoundFile &sndFile = pModDoc->GetSoundFile();
CriticalSection cs;
if(!pModDoc->IsChannelMuted(chn))
{
// Cut playing notes
sndFile.ChnSettings[chn].dwFlags.set(CHN_MUTE);
pModDoc->UpdateChannelMuteStatus(chn);
sndFile.ChnSettings[chn].dwFlags.reset(CHN_MUTE);
}
sndFile.m_PlayState.Chn[chn].Reset(ModChannel::resetTotal, sndFile, chn, CSoundFile::GetChannelMuteFlag());
}
void CViewPattern::OnMuteFromClick()
{
OnMuteChannel(m_MenuCursor.GetChannel());
}
void CViewPattern::OnMuteChannel(CHANNELINDEX chn)
{
CModDoc *pModDoc = GetDocument();
if(pModDoc)
{
pModDoc->SoloChannel(chn, false);
pModDoc->MuteChannel(chn, !pModDoc->IsChannelMuted(chn));
//If we just unmuted a channel, make sure none are still considered "solo".
if(!pModDoc->IsChannelMuted(chn))
{
for(CHANNELINDEX i = 0; i < pModDoc->GetNumChannels(); i++)
{
pModDoc->SoloChannel(i, false);
}
}
InvalidateChannelsHeaders();
pModDoc->UpdateAllViews(this, GeneralHint(chn).Channels());
}
}
void CViewPattern::OnSoloFromClick()
{
OnSoloChannel(m_MenuCursor.GetChannel());
}
// When trying to solo a channel that is already the only unmuted channel,
// this will result in unmuting all channels, in order to satisfy user habits.
// In all other cases, soloing a channel unsoloes all and mutes all except this channel
void CViewPattern::OnSoloChannel(CHANNELINDEX chn)
{
CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr)
return;
if(chn >= pModDoc->GetNumChannels())
{
return;
}
if(pModDoc->IsChannelSolo(chn))
{
bool nChnIsOnlyUnMutedChan = true;
for(CHANNELINDEX i = 0; i < pModDoc->GetNumChannels(); i++) //check status of all other chans
{
if(i != chn && !pModDoc->IsChannelMuted(i))
{
nChnIsOnlyUnMutedChan = false; //found a channel that isn't muted!
break;
}
}
if(nChnIsOnlyUnMutedChan) // this is the only playable channel and it is already soloed -> Unmute all
{
OnUnmuteAll();
return;
}
}
for(CHANNELINDEX i = 0; i < pModDoc->GetNumChannels(); i++)
{
pModDoc->MuteChannel(i, !(i == chn)); //mute all chans except nChn, unmute nChn
pModDoc->SoloChannel(i, (i == chn)); //unsolo all chans except nChn, solo nChn
}
InvalidateChannelsHeaders();
pModDoc->UpdateAllViews(this, GeneralHint(chn).Channels());
}
void CViewPattern::OnRecordSelect()
{
CModDoc *pModDoc = GetDocument();
if(pModDoc)
{
CHANNELINDEX chn = m_MenuCursor.GetChannel();
if(chn < pModDoc->GetNumChannels())
{
pModDoc->ToggleChannelRecordGroup(chn, RecordGroup::Group1);
InvalidateChannelsHeaders(chn);
}
}
}
void CViewPattern::OnSplitRecordSelect()
{
CModDoc *pModDoc = GetDocument();
if(pModDoc)
{
CHANNELINDEX chn = m_MenuCursor.GetChannel();
if(chn < pModDoc->GetNumChannels())
{
pModDoc->ToggleChannelRecordGroup(chn, RecordGroup::Group2);
InvalidateChannelsHeaders(chn);
}
}
}
void CViewPattern::OnUnmuteAll()
{
CModDoc *pModDoc = GetDocument();
if(pModDoc)
{
const CHANNELINDEX numChannels = pModDoc->GetNumChannels();
for(CHANNELINDEX chn = 0; chn < numChannels; chn++)
{
pModDoc->MuteChannel(chn, false);
pModDoc->SoloChannel(chn, false);
}
InvalidateChannelsHeaders();
}
}
bool CViewPattern::InsertOrDeleteRows(CHANNELINDEX firstChn, CHANNELINDEX lastChn, bool globalEdit, bool deleteRows)
{
CModDoc &modDoc = *GetDocument();
CSoundFile &sndFile = *GetSoundFile();
if(!sndFile.Patterns.IsValidPat(m_nPattern) || !IsEditingEnabled_bmsg())
return false;
LimitMax(lastChn, CHANNELINDEX(sndFile.GetNumChannels() - 1));
if(firstChn > lastChn)
return false;
const auto selection = (firstChn != lastChn || m_Selection.GetNumRows() > 1) ? PatternRect{{m_Selection.GetStartRow(), firstChn, PatternCursor::firstColumn}, {m_Selection.GetEndRow(), lastChn, PatternCursor::lastColumn}} : m_Selection;
const ROWINDEX numRows = selection.GetNumRows();
const char *undoDescription = "";
if(deleteRows)
undoDescription = numRows != 1 ? "Delete Rows" : "Delete Row";
else
undoDescription = numRows != 1 ? "Insert Rows" : "Insert Row";
const ROWINDEX startRow = selection.GetStartRow();
const CHANNELINDEX numChannels = lastChn - firstChn + 1;
std::vector<PATTERNINDEX> patterns;
if(globalEdit)
{
auto &order = Order();
const auto start = order.begin() + GetCurrentOrder();
const auto end = std::find(start, order.end(), order.GetInvalidPatIndex());
// As this is a global operation, ensure that all modified patterns are unique
bool orderListChanged = false;
const ORDERINDEX ordEnd = GetCurrentOrder() + static_cast<ORDERINDEX>(std::distance(start, end));
for(ORDERINDEX ord = GetCurrentOrder(); ord < ordEnd; ord++)
{
const auto pat = order[ord];
if(pat != order.EnsureUnique(ord))
orderListChanged = true;
}
if(orderListChanged)
modDoc.UpdateAllViews(this, SequenceHint().Data(), nullptr);
patterns.assign(start, end);
} else
{
patterns = {m_nPattern};
}
// Backup source data and create undo points
std::vector<ModCommand> patternData;
if(!deleteRows)
patternData.insert(patternData.begin(), numRows * numChannels, ModCommand{});
bool first = true;
for(auto pat : patterns)
{
if(!sndFile.Patterns.IsValidPat(pat))
continue;
const auto &pattern = sndFile.Patterns[pat];
const ROWINDEX firstRow = first ? startRow : 0;
for(ROWINDEX row = firstRow; row < pattern.GetNumRows(); row++)
{
const auto *m = pattern.GetpModCommand(row, firstChn);
patternData.insert(patternData.end(), m, m + numChannels);
}
modDoc.GetPatternUndo().PrepareUndo(pat, firstChn, firstRow, numChannels, pattern.GetNumRows(), undoDescription, !first);
first = false;
}
if(deleteRows)
patternData.insert(patternData.end(), numRows * numChannels, ModCommand{});
// Now do the actual shifting
auto src = patternData.cbegin();
if(deleteRows)
src += numRows * numChannels;
PATTERNINDEX firstNewPattern = m_nPattern;
first = true;
for(auto pat : patterns)
{
if(!sndFile.Patterns.IsValidPat(pat))
continue;
auto &pattern = sndFile.Patterns[pat];
for(ROWINDEX row = first ? startRow : 0; row < pattern.GetNumRows(); row++, src += numChannels)
{
ModCommand *dest = pattern.GetpModCommand(row, firstChn);
std::copy(src, src + numChannels, dest);
}
if(first)
firstNewPattern = pat;
first = false;
modDoc.UpdateAllViews(this, PatternHint(pat).Data(), this);
}
SetModified();
SetCurrentPattern(firstNewPattern);
InvalidatePattern();
SetCursorPosition(selection.GetUpperLeft());
SetCurSel(selection);
return true;
}
void CViewPattern::DeleteRows(CHANNELINDEX firstChn, CHANNELINDEX lastChn, bool globalEdit)
{
InsertOrDeleteRows(firstChn, lastChn, globalEdit, true);
}
void CViewPattern::OnDeleteRow()
{
DeleteRows(m_Selection.GetStartChannel(), m_Selection.GetEndChannel());
}
void CViewPattern::OnDeleteWholeRow()
{
DeleteRows(0, GetSoundFile()->GetNumChannels() - 1);
}
void CViewPattern::OnDeleteRowGlobal()
{
DeleteRows(m_Selection.GetStartChannel(), m_Selection.GetEndChannel(), true);
}
void CViewPattern::OnDeleteWholeRowGlobal()
{
DeleteRows(0, GetSoundFile()->GetNumChannels() - 1, true);
}
void CViewPattern::InsertRows(CHANNELINDEX firstChn, CHANNELINDEX lastChn, bool globalEdit)
{
InsertOrDeleteRows(firstChn, lastChn, globalEdit, false);
}
void CViewPattern::OnInsertRow()
{
InsertRows(m_Selection.GetStartChannel(), m_Selection.GetEndChannel());
}
void CViewPattern::OnInsertWholeRow()
{
InsertRows(0, GetSoundFile()->GetNumChannels() - 1);
}
void CViewPattern::OnInsertRowGlobal()
{
InsertRows(m_Selection.GetStartChannel(), m_Selection.GetEndChannel(), true);
}
void CViewPattern::OnInsertWholeRowGlobal()
{
InsertRows(0, GetSoundFile()->GetNumChannels() - 1, true);
}
void CViewPattern::OnSplitPattern()
{
COrderList &orderList = static_cast<CCtrlPatterns *>(GetControlDlg())->GetOrderList();
CSoundFile &sndFile = *GetSoundFile();
const auto &specs = sndFile.GetModSpecifications();
const PATTERNINDEX sourcePat = m_nPattern;
const ROWINDEX splitRow = m_MenuCursor.GetRow();
if(splitRow < 1 || !sndFile.Patterns.IsValidPat(sourcePat) || !sndFile.Patterns[sourcePat].IsValidRow(splitRow))
{
MessageBeep(MB_ICONWARNING);
return;
}
// Create a new pattern (ignore if it's too big for this format - if it is, then the source pattern already was too big, too)
CriticalSection cs;
const ROWINDEX numSplitRows = sndFile.Patterns[sourcePat].GetNumRows() - splitRow;
const PATTERNINDEX newPat = sndFile.Patterns.InsertAny(std::max(specs.patternRowsMin, numSplitRows), false);
if(newPat == PATTERNINDEX_INVALID)
{
cs.Leave();
Reporting::Error(MPT_AFORMAT("Pattern limit of the {} format ({} patterns) has been reached.")(mpt::ToUpperCaseAscii(specs.fileExtension), specs.patternsMax), "Split Pattern");
return;
}
auto &sourcePattern = sndFile.Patterns[sourcePat];
auto &newPattern = sndFile.Patterns[newPat];
auto &undo = GetDocument()->GetPatternUndo();
undo.PrepareUndo(sourcePat, 0, splitRow, sourcePattern.GetNumChannels(), numSplitRows, "Split Pattern");
undo.PrepareUndo(newPat, 0, 0, newPattern.GetNumChannels(), newPattern.GetNumRows(), "Split Pattern", true);
auto copyStart = sourcePattern.begin() + sourcePattern.GetNumChannels() * splitRow;
std::copy(copyStart, sourcePattern.end(), newPattern.begin());
// Reduce the row number or insert pattern breaks, if the patterns are too small for the format
sourcePattern.Resize(std::max(specs.patternRowsMin, splitRow));
if(splitRow != sourcePattern.GetNumRows())
{
std::fill(copyStart, sourcePattern.end(), ModCommand::Empty());
sourcePattern.WriteEffect(EffectWriter(CMD_PATTERNBREAK, 0).Row(splitRow - 1).RetryNextRow());
}
if(numSplitRows != newPattern.GetNumRows())
{
newPattern.WriteEffect(EffectWriter(CMD_PATTERNBREAK, 0).Row(numSplitRows - 1).RetryNextRow());
}
// Update every occurrence of the split pattern in all order lists
auto editOrd = GetCurrentOrder();
for(SEQUENCEINDEX seq = 0; seq < sndFile.Order.GetNumSequences(); seq++)
{
const bool isCurrentSeq = (seq == sndFile.Order.GetCurrentSequenceIndex());
bool editedSeq = false;
auto &order = sndFile.Order(seq);
for(ORDERINDEX i = 0; i < order.GetLength(); i++)
{
if(order[i] == sourcePat)
{
if(!order.insert(i + 1, 1, newPat))
continue;
editedSeq = true;
if(isCurrentSeq)
orderList.InsertUpdatePlaystate(i, i + 1);
i++;
// Slide the current selection accordingly so it doesn't end up in the wrong id
if(i < editOrd && isCurrentSeq)
editOrd++;
}
}
if(editedSeq)
GetDocument()->UpdateAllViews(nullptr, SequenceHint(seq).Data(), this);
}
orderList.SetSelection(editOrd + 1);
SetCurrentRow(0);
SetModified(true);
GetDocument()->UpdateAllViews(nullptr, PatternHint(newPat).Names().Data(), this);
}
void CViewPattern::OnEditGoto()
{
CModDoc *pModDoc = GetDocument();
if(!pModDoc)
return;
ORDERINDEX curOrder = GetCurrentOrder();
CHANNELINDEX curChannel = GetCurrentChannel() + 1;
CPatternGotoDialog dlg(this, GetCurrentRow(), curChannel, m_nPattern, curOrder, pModDoc->GetSoundFile());
if(dlg.DoModal() == IDOK)
{
if(dlg.m_nPattern != m_nPattern)
SetCurrentPattern(dlg.m_nPattern);
if(dlg.m_nOrder != curOrder)
SetCurrentOrder(dlg.m_nOrder);
if(dlg.m_nChannel != curChannel)
SetCurrentColumn(dlg.m_nChannel - 1);
if(dlg.m_nRow != GetCurrentRow())
SetCurrentRow(dlg.m_nRow);
CriticalSection cs;
pModDoc->SetElapsedTime(dlg.m_nOrder, dlg.m_nRow, false);
}
return;
}
void CViewPattern::OnPatternStep()
{
PatternStep();
}
void CViewPattern::PatternStep(ROWINDEX row)
{
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
CModDoc *pModDoc = GetDocument();
if(pMainFrm != nullptr && pModDoc != nullptr)
{
CSoundFile &sndFile = pModDoc->GetSoundFile();
if(!sndFile.Patterns.IsValidPat(m_nPattern))
return;
CriticalSection cs;
// In case we were previously in smooth scrolling mode during live playback, the pattern might be misaligned.
if(GetSmoothScrollOffset() != 0)
InvalidatePattern(true, true);
// Cut instruments/samples in virtual channels
for(CHANNELINDEX i = sndFile.GetNumChannels(); i < MAX_CHANNELS; i++)
{
sndFile.m_PlayState.Chn[i].dwFlags.set(CHN_NOTEFADE | CHN_KEYOFF);
}
sndFile.LoopPattern(m_nPattern);
sndFile.m_PlayState.m_nNextRow = row == ROWINDEX_INVALID ? GetCurrentRow() : row;
sndFile.m_SongFlags.reset(SONG_PAUSED);
sndFile.m_SongFlags.set(SONG_STEP);
SetPlayCursor(m_nPattern, sndFile.m_PlayState.m_nNextRow, 0);
cs.Leave();
if(pMainFrm->GetModPlaying() != pModDoc)
{
pModDoc->SetFollowWnd(m_hWnd);
pMainFrm->PlayMod(pModDoc);
}
pModDoc->SetNotifications(Notification::Position | Notification::VUMeters);
if(row == ROWINDEX_INVALID)
{
SetCurrentRow(GetCurrentRow() + 1,
(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL) || // Wrap around to next pattern if continous scroll is enabled...
(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_WRAP)); // ...or otherwise if cursor wrap is enabled.
}
SetFocus();
}
}
// Copy cursor to internal clipboard
void CViewPattern::OnCursorCopy()
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidPat(m_nPattern))
{
return;
}
const ModCommand &m = GetCursorCommand();
switch(m_Cursor.GetColumnType())
{
case PatternCursor::noteColumn:
case PatternCursor::instrColumn:
m_cmdOld.note = m.note;
m_cmdOld.instr = m.instr;
SendCtrlMessage(CTRLMSG_SETCURRENTINSTRUMENT, m_cmdOld.instr);
break;
case PatternCursor::volumeColumn:
m_cmdOld.volcmd = m.volcmd;
m_cmdOld.vol = m.vol;
break;
case PatternCursor::effectColumn:
case PatternCursor::paramColumn:
m_cmdOld.command = m.command;
m_cmdOld.param = m.param;
break;
}
}
// Paste cursor from internal clipboard
void CViewPattern::OnCursorPaste()
{
if(!IsEditingEnabled_bmsg())
{
return;
}
PrepareUndo(m_Cursor, m_Cursor, "Cursor Paste");
PatternCursor::Columns column = m_Cursor.GetColumnType();
ModCommand &m = GetCursorCommand();
switch(column)
{
case PatternCursor::noteColumn:
m.note = m_cmdOld.note;
[[fallthrough]];
case PatternCursor::instrColumn:
m.instr = m_cmdOld.instr;
break;
case PatternCursor::volumeColumn:
m.vol = m_cmdOld.vol;
m.volcmd = m_cmdOld.volcmd;
break;
case PatternCursor::effectColumn:
case PatternCursor::paramColumn:
m.command = m_cmdOld.command;
m.param = m_cmdOld.param;
break;
}
SetModified(false);
// Preview Row
if((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_PLAYEDITROW) && !IsLiveRecord())
{
PatternStep(GetCurrentRow());
}
if(GetSoundFile()->IsPaused() || !m_Status[psFollowSong] || (CMainFrame::GetMainFrame() && CMainFrame::GetMainFrame()->GetFollowSong(GetDocument()) != m_hWnd))
{
InvalidateCell(m_Cursor);
SetCurrentRow(GetCurrentRow() + m_nSpacing);
SetSelToCursor();
}
}
void CViewPattern::OnVisualizeEffect()
{
CModDoc *pModDoc = GetDocument();
if(pModDoc != nullptr && pModDoc->GetSoundFile().Patterns.IsValidPat(m_nPattern))
{
const ROWINDEX row0 = m_Selection.GetStartRow(), row1 = m_Selection.GetEndRow();
const CHANNELINDEX nchn = m_Selection.GetStartChannel();
if(m_pEffectVis)
{
// Window already there, update data
m_pEffectVis->UpdateSelection(row0, row1, nchn, m_nPattern);
} else
{
// Open window & send data
CriticalSection cs;
try
{
m_pEffectVis = std::make_unique<CEffectVis>(this, row0, row1, nchn, *pModDoc, m_nPattern);
m_pEffectVis->OpenEditor(CMainFrame::GetMainFrame());
// HACK: to get status window set up; must create clear destinction between
// construction, 1st draw code and all draw code.
m_pEffectVis->OnSize(0, 0, 0);
} catch(mpt::out_of_memory e)
{
mpt::delete_out_of_memory(e);
}
}
}
}
// Helper function for sweeping the pattern up and down to find suitable start and end points for interpolation.
// startCond must return true for the start row, endCond must return true for the end row.
PatternRect CViewPattern::SweepPattern(bool(*startCond)(const ModCommand &), bool(*endCond)(const ModCommand &, const ModCommand &)) const
{
const auto &pattern = GetSoundFile()->Patterns[m_nPattern];
const ROWINDEX numRows = pattern.GetNumRows();
const ROWINDEX cursorRow = m_Selection.GetStartRow();
if(cursorRow >= numRows)
return {};
const ModCommand *start = pattern.GetpModCommand(cursorRow, m_Selection.GetStartChannel()), *end = start;
// Sweep up
ROWINDEX startRow = ROWINDEX_INVALID;
for(ROWINDEX row = 0; row <= cursorRow; row++, start -= pattern.GetNumChannels())
{
if(startCond(*start))
{
startRow = cursorRow - row;
break;
}
}
if(startRow == ROWINDEX_INVALID)
return {};
// Sweep down
ROWINDEX endRow = ROWINDEX_INVALID;
for(ROWINDEX row = cursorRow; row < numRows; row++, end += pattern.GetNumChannels())
{
if(endCond(*start, *end))
{
endRow = row;
break;
}
}
if(endRow == ROWINDEX_INVALID)
return {};
return {PatternCursor(startRow, m_Selection.GetUpperLeft()), PatternCursor(endRow, m_Selection.GetUpperLeft())};
}
void CViewPattern::Interpolate(PatternCursor::Columns type)
{
CSoundFile *sndFile = GetSoundFile();
if(sndFile == nullptr || !sndFile->Patterns.IsValidPat(m_nPattern) || !IsEditingEnabled())
return;
bool changed = false;
std::vector<CHANNELINDEX> validChans;
if(type == PatternCursor::effectColumn || type == PatternCursor::paramColumn)
{
std::vector<CHANNELINDEX> effectChans;
std::vector<CHANNELINDEX> paramChans;
ListChansWhereColSelected(PatternCursor::effectColumn, effectChans);
ListChansWhereColSelected(PatternCursor::paramColumn, paramChans);
validChans.resize(effectChans.size() + paramChans.size());
validChans.resize(std::set_union(effectChans.begin(), effectChans.end(), paramChans.begin(), paramChans.end(), validChans.begin()) - validChans.begin());
} else
{
ListChansWhereColSelected(type, validChans);
}
if(m_Selection.GetUpperLeft() == m_Selection.GetLowerRight() && !validChans.empty())
{
// No selection has been made: Interpolate between closest non-zero values in this column.
PatternRect sweepSelection;
switch(type)
{
case PatternCursor::noteColumn:
// Allow note-to-note interpolation only.
sweepSelection = SweepPattern(
[](const ModCommand &start) { return start.note != NOTE_NONE; },
[](const ModCommand &start, const ModCommand &end) { return start.IsNote() && end.IsNote(); });
break;
case PatternCursor::instrColumn:
// Allow interpolation between same instrument, as long as it's not a PC note.
sweepSelection = SweepPattern(
[](const ModCommand &start) { return start.instr != 0 && !start.IsPcNote(); },
[](const ModCommand &start, const ModCommand &end) { return end.instr == start.instr; });
break;
case PatternCursor::volumeColumn:
// Allow interpolation between same volume effect, as long as it's not a PC note.
sweepSelection = SweepPattern(
[](const ModCommand &start) { return start.volcmd != VOLCMD_NONE && !start.IsPcNote(); },
[](const ModCommand &start, const ModCommand &end) { return end.volcmd == start.volcmd && !end.IsPcNote(); });
break;
case PatternCursor::effectColumn:
case PatternCursor::paramColumn:
// Allow interpolation between same effect, or anything if it's a PC note.
sweepSelection = SweepPattern(
[](const ModCommand &start) { return start.command != CMD_NONE || start.IsPcNote(); },
[](const ModCommand &start, const ModCommand &end) { return (end.command == start.command || start.IsPcNote()) && (!start.IsPcNote() || end.IsPcNote()); });
break;
}
if(sweepSelection.GetNumRows() > 1)
{
// Found usable end and start commands: Extend selection.
SetCurSel(sweepSelection);
}
}
const ROWINDEX row0 = m_Selection.GetStartRow(), row1 = m_Selection.GetEndRow();
//for all channels where type is selected
for(auto nchn : validChans)
{
if(!IsInterpolationPossible(row0, row1, nchn, type))
continue; //skip chans where interpolation isn't possible
if(!changed) //ensure we save undo buffer only before any channels are interpolated
{
const char *description = "";
switch(type)
{
case PatternCursor::noteColumn:
description = "Interpolate Note Column";
break;
case PatternCursor::instrColumn:
description = "Interpolate Instrument Column";
break;
case PatternCursor::volumeColumn:
description = "Interpolate Volume Column";
break;
case PatternCursor::effectColumn:
case PatternCursor::paramColumn:
description = "Interpolate Effect Column";
break;
}
PrepareUndo(m_Selection, description);
}
bool doPCinterpolation = false;
int vsrc, vdest, vcmd = 0, verr = 0, distance = row1 - row0;
const ModCommand srcCmd = *sndFile->Patterns[m_nPattern].GetpModCommand(row0, nchn);
const ModCommand destCmd = *sndFile->Patterns[m_nPattern].GetpModCommand(row1, nchn);
ModCommand::NOTE PCnote = NOTE_NONE;
uint16 PCinst = 0, PCparam = 0;
switch(type)
{
case PatternCursor::noteColumn:
vsrc = srcCmd.note;
vdest = destCmd.note;
vcmd = srcCmd.instr;
verr = (distance * (NOTE_MAX - 1)) / NOTE_MAX;
if(srcCmd.note == NOTE_NONE)
{
vsrc = vdest;
vcmd = destCmd.note;
} else if(destCmd.note == NOTE_NONE)
{
vdest = vsrc;
}
break;
case PatternCursor::instrColumn:
vsrc = srcCmd.instr;
vdest = destCmd.instr;
verr = (distance * 63) / 128;
if(srcCmd.instr == 0)
{
vsrc = vdest;
vcmd = destCmd.instr;
} else if(destCmd.instr == 0)
{
vdest = vsrc;
}
break;
case PatternCursor::volumeColumn:
vsrc = srcCmd.vol;
vdest = destCmd.vol;
vcmd = srcCmd.volcmd;
verr = (distance * 63) / 128;
if(srcCmd.volcmd == VOLCMD_NONE)
{
vcmd = destCmd.volcmd;
if(vcmd == VOLCMD_VOLUME && srcCmd.IsNote() && srcCmd.instr)
vsrc = GetDefaultVolume(srcCmd);
else
vsrc = vdest;
} else if(destCmd.volcmd == VOLCMD_NONE)
{
if(vcmd == VOLCMD_VOLUME && destCmd.IsNote() && destCmd.instr)
vdest = GetDefaultVolume(srcCmd);
else
vdest = vsrc;
}
break;
case PatternCursor::paramColumn:
case PatternCursor::effectColumn:
if(srcCmd.IsPcNote() || destCmd.IsPcNote())
{
doPCinterpolation = true;
PCnote = (srcCmd.IsPcNote()) ? srcCmd.note : destCmd.note;
vsrc = srcCmd.GetValueEffectCol();
vdest = destCmd.GetValueEffectCol();
PCparam = srcCmd.GetValueVolCol();
if((PCparam == 0 && destCmd.IsPcNote()) || !srcCmd.IsPcNote())
PCparam = destCmd.GetValueVolCol();
PCinst = srcCmd.instr;
if(PCinst == 0)
PCinst = destCmd.instr;
} else
{
vsrc = srcCmd.param;
vdest = destCmd.param;
vcmd = srcCmd.command;
if(srcCmd.command == CMD_NONE)
{
vsrc = vdest;
vcmd = destCmd.command;
} else if(destCmd.command == CMD_NONE)
{
vdest = vsrc;
}
}
verr = (distance * 63) / 128;
break;
default:
MPT_ASSERT(false);
return;
}
if(vdest < vsrc)
verr = -verr;
ModCommand *pcmd = sndFile->Patterns[m_nPattern].GetpModCommand(row0, nchn);
for(int i = 0; i <= distance; i++, pcmd += sndFile->GetNumChannels())
{
switch(type)
{
case PatternCursor::noteColumn:
if((pcmd->note == NOTE_NONE || pcmd->instr == vcmd) && !pcmd->IsPcNote())
{
int note = vsrc + ((vdest - vsrc) * i + verr) / distance;
pcmd->note = static_cast<ModCommand::NOTE>(note);
if(pcmd->instr == 0)
pcmd->instr = static_cast<ModCommand::VOLCMD>(vcmd);
}
break;
case PatternCursor::instrColumn:
if(pcmd->instr == 0)
{
int instr = vsrc + ((vdest - vsrc) * i + verr) / distance;
pcmd->instr = static_cast<ModCommand::INSTR>(instr);
}
break;
case PatternCursor::volumeColumn:
if((pcmd->volcmd == VOLCMD_NONE || pcmd->volcmd == vcmd) && !pcmd->IsPcNote())
{
int vol = vsrc + ((vdest - vsrc) * i + verr) / distance;
pcmd->vol = static_cast<ModCommand::VOL>(vol);
pcmd->volcmd = static_cast<ModCommand::VOLCMD>(vcmd);
}
break;
case PatternCursor::effectColumn:
if(doPCinterpolation)
{ // With PC/PCs notes, copy PCs note and plug index to all rows where
// effect interpolation is done if no PC note with non-zero instrument is there.
const uint16 val = static_cast<uint16>(vsrc + ((vdest - vsrc) * i + verr) / distance);
if(!pcmd->IsPcNote() || pcmd->instr == 0)
{
pcmd->note = PCnote;
pcmd->instr = static_cast<ModCommand::INSTR>(PCinst);
}
pcmd->SetValueVolCol(PCparam);
pcmd->SetValueEffectCol(val);
} else if(!pcmd->IsPcNote())
{
if((pcmd->command == CMD_NONE) || (pcmd->command == vcmd))
{
int val = vsrc + ((vdest - vsrc) * i + verr) / distance;
pcmd->param = static_cast<ModCommand::PARAM>(val);
pcmd->command = static_cast<ModCommand::COMMAND>(vcmd);
}
}
break;
default:
MPT_ASSERT(false);
}
}
changed = true;
} //end for all channels where type is selected
if(changed)
{
SetModified(false);
InvalidatePattern(false);
}
}
void CViewPattern::OnResetChannelColors()
{
CModDoc &modDoc = *GetDocument();
const CSoundFile &sndFile = *GetSoundFile();
modDoc.GetPatternUndo().PrepareChannelUndo(0, sndFile.GetNumChannels(), "Reset Channel Colours");
if(modDoc.SetDefaultChannelColors())
{
if(modDoc.SupportsChannelColors())
modDoc.SetModified();
modDoc.UpdateAllViews(nullptr, GeneralHint().Channels(), nullptr);
} else
{
modDoc.GetPatternUndo().RemoveLastUndoStep();
}
}
void CViewPattern::OnTransposeChannel()
{
CInputDlg dlg(this, _T("Enter transpose amount (affects all patterns):"), -(NOTE_MAX - NOTE_MIN), (NOTE_MAX - NOTE_MIN), m_nTransposeAmount);
if(dlg.DoModal() == IDOK)
{
m_nTransposeAmount = dlg.resultAsInt;
CSoundFile &sndFile = *GetSoundFile();
bool changed = false;
// Don't allow notes outside our supported note range.
const ModCommand::NOTE noteMin = sndFile.GetModSpecifications().noteMin;
const ModCommand::NOTE noteMax = sndFile.GetModSpecifications().noteMax;
for(PATTERNINDEX pat = 0; pat < sndFile.Patterns.Size(); pat++)
{
bool changedThisPat = false;
if(sndFile.Patterns.IsValidPat(pat))
{
ModCommand *m = sndFile.Patterns[pat].GetpModCommand(0, m_MenuCursor.GetChannel());
const ROWINDEX numRows = sndFile.Patterns[pat].GetNumRows();
for(ROWINDEX row = 0; row < numRows; row++)
{
if(m->IsNote())
{
if(!changedThisPat)
{
GetDocument()->GetPatternUndo().PrepareUndo(pat, m_MenuCursor.GetChannel(), 0, 1, numRows, "Transpose Channel", changed);
changed = changedThisPat = true;
}
int note = m->note + m_nTransposeAmount;
Limit(note, noteMin, noteMax);
m->note = static_cast<ModCommand::NOTE>(note);
}
m += sndFile.Patterns[pat].GetNumChannels();
}
}
}
if(changed)
{
SetModified(true);
InvalidatePattern(false);
}
}
}
void CViewPattern::OnTransposeCustom()
{
CInputDlg dlg(this, _T("Enter transpose amount:"), -(NOTE_MAX - NOTE_MIN), (NOTE_MAX - NOTE_MIN), m_nTransposeAmount);
if(dlg.DoModal() == IDOK)
{
m_nTransposeAmount = dlg.resultAsInt;
TransposeSelection(dlg.resultAsInt);
}
}
void CViewPattern::OnTransposeCustomQuick()
{
if(m_nTransposeAmount != 0)
TransposeSelection(m_nTransposeAmount);
else
OnTransposeCustom();
}
bool CViewPattern::TransposeSelection(int transp)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidPat(m_nPattern))
{
return false;
}
m_Selection.Sanitize(pSndFile->Patterns[m_nPattern].GetNumRows(), pSndFile->GetNumChannels());
// Don't allow notes outside our supported note range.
const ModCommand::NOTE noteMin = pSndFile->GetModSpecifications().noteMin;
const ModCommand::NOTE noteMax = pSndFile->GetModSpecifications().noteMax;
PrepareUndo(m_Selection, "Transpose");
std::vector<int> lastGroupSize(pSndFile->GetNumChannels(), 12);
ApplyToSelection([&] (ModCommand &m, ROWINDEX, CHANNELINDEX chn)
{
if(chn == m_Selection.GetStartChannel() && m_Selection.GetStartColumn() > PatternCursor::noteColumn)
return;
if(m.IsNote())
{
if(m.instr > 0)
{
lastGroupSize[chn] = GetDocument()->GetInstrumentGroupSize(m.instr);
}
int transpose = transp;
if(transpose == 12000 || transpose == -12000)
{
// Transpose one octave
transpose = lastGroupSize[chn] * mpt::signum(transpose);
}
int note = m.note + transpose;
Limit(note, noteMin, noteMax);
m.note = static_cast<ModCommand::NOTE>(note);
}
});
SetModified(false);
InvalidateSelection();
if(m_Selection.GetNumChannels() == 1 && m_Selection.GetNumRows() == 1 && (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_PLAYTRANSPOSE))
{
// Preview a single transposed note
PreviewNote(m_Selection.GetStartRow(), m_Selection.GetStartChannel());
}
return true;
}
bool CViewPattern::DataEntry(bool up, bool coarse)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidPat(m_nPattern))
{
return false;
}
m_Selection.Sanitize(pSndFile->Patterns[m_nPattern].GetNumRows(), pSndFile->GetNumChannels());
const PatternCursor::Columns column = m_Selection.GetStartColumn();
// Don't allow notes outside our supported note range.
const ModCommand::NOTE noteMin = pSndFile->GetModSpecifications().noteMin;
const ModCommand::NOTE noteMax = pSndFile->GetModSpecifications().noteMax;
const int instrMax = std::min(static_cast<int>(Util::MaxValueOfType(ModCommand::INSTR())), static_cast<int>(pSndFile->GetNumInstruments() ? pSndFile->GetNumInstruments() : pSndFile->GetNumSamples()));
const EffectInfo effectInfo(*pSndFile);
const int offset = up ? 1 : -1;
PrepareUndo(m_Selection, "Data Entry");
// Notes per octave for non-TET12 tunings and coarse note steps
std::vector<int> lastGroupSize(pSndFile->GetNumChannels(), 12);
bool applyToSpecialNotes = true;
if(column == PatternCursor::noteColumn)
{
const CPattern &pattern = pSndFile->Patterns[m_nPattern];
const CHANNELINDEX startChn = m_Selection.GetStartChannel(), endChn = m_Selection.GetEndChannel();
const ROWINDEX endRow = m_Selection.GetEndRow();
for(ROWINDEX row = m_Selection.GetStartRow(); row <= endRow && applyToSpecialNotes; row++)
{
const ModCommand *m = pattern.GetpModCommand(row, startChn);
for(CHANNELINDEX chn = startChn; chn <= endChn; chn++, m++)
{
if(!m_Selection.ContainsHorizontal(PatternCursor(0, chn, PatternCursor::noteColumn)))
continue;
if(m->IsNote())
{
applyToSpecialNotes = false;
break;
}
}
}
}
ApplyToSelection([&] (ModCommand &m, ROWINDEX, CHANNELINDEX chn)
{
if(column == PatternCursor::noteColumn && m_Selection.ContainsHorizontal(PatternCursor(0, chn, PatternCursor::noteColumn)))
{
// Increase / decrease note
if(m.IsNote() && !applyToSpecialNotes)
{
if(m.instr > 0)
{
lastGroupSize[chn] = GetDocument()->GetInstrumentGroupSize(m.instr);
}
int note = m.note + offset * (coarse ? lastGroupSize[chn] : 1);
Limit(note, noteMin, noteMax);
m.note = (ModCommand::NOTE)note;
} else if(m.IsSpecialNote() && applyToSpecialNotes)
{
ModCommand::NOTE note = m.note;
do
{
note = static_cast<ModCommand::NOTE>(note + offset);
if(!ModCommand::IsSpecialNote(note))
{
break;
}
} while(!pSndFile->GetModSpecifications().HasNote(note));
if(ModCommand::IsSpecialNote(note))
{
if(m.IsPcNote() != ModCommand::IsPcNote(note))
{
m.Clear();
}
m.note = (ModCommand::NOTE)note;
}
}
}
if(column == PatternCursor::instrColumn && m_Selection.ContainsHorizontal(PatternCursor(0, chn, PatternCursor::instrColumn)) && m.instr != 0)
{
// Increase / decrease instrument
int instr = m.instr + offset * (coarse ? 10 : 1);
Limit(instr, 1, m.IsInstrPlug() ? MAX_MIXPLUGINS : instrMax);
m.instr = (ModCommand::INSTR)instr;
}
if(column == PatternCursor::volumeColumn && m_Selection.ContainsHorizontal(PatternCursor(0, chn, PatternCursor::volumeColumn)))
{
// Increase / decrease volume parameter
if(m.IsPcNote())
{
int val = m.GetValueVolCol() + offset * (coarse ? 10 : 1);
Limit(val, 0, ModCommand::maxColumnValue);
m.SetValueVolCol(static_cast<uint16>(val));
} else
{
int vol = m.vol + offset * (coarse ? 10 : 1);
if(m.volcmd == VOLCMD_NONE && m.IsNote() && m.instr)
{
m.volcmd = VOLCMD_VOLUME;
vol = GetDefaultVolume(m);
}
ModCommand::VOL minValue = 0, maxValue = 64;
effectInfo.GetVolCmdInfo(effectInfo.GetIndexFromVolCmd(m.volcmd), nullptr, &minValue, &maxValue);
Limit(vol, (int)minValue, (int)maxValue);
m.vol = (ModCommand::VOL)vol;
}
}
if((column == PatternCursor::effectColumn || column == PatternCursor::paramColumn) && (m_Selection.ContainsHorizontal(PatternCursor(0, chn, PatternCursor::effectColumn)) || m_Selection.ContainsHorizontal(PatternCursor(0, chn, PatternCursor::paramColumn))))
{
// Increase / decrease effect parameter
if(m.IsPcNote())
{
int val = m.GetValueEffectCol() + offset * (coarse ? 10 : 1);
Limit(val, 0, ModCommand::maxColumnValue);
m.SetValueEffectCol(static_cast<uint16>(val));
} else
{
int param = m.param + offset * (coarse ? 16 : 1);
ModCommand::PARAM minValue = 0x00, maxValue = 0xFF;
if(!m.IsSlideUpDownCommand())
{
const auto effectIndex = effectInfo.GetIndexFromEffect(m.command, m.param);
effectInfo.GetEffectInfo(effectIndex, nullptr, false, &minValue, &maxValue);
minValue = static_cast<ModCommand::PARAM>(effectInfo.MapPosToValue(effectIndex, minValue));
maxValue = static_cast<ModCommand::PARAM>(effectInfo.MapPosToValue(effectIndex, maxValue));
}
m.param = static_cast<ModCommand::PARAM>(Clamp(param, minValue, maxValue));
}
}
});
SetModified(false);
InvalidatePattern();
if(column == PatternCursor::noteColumn && m_Selection.GetNumChannels() == 1 && m_Selection.GetNumRows() == 1 && (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_PLAYTRANSPOSE))
{
// Preview a single transposed note
PreviewNote(m_Selection.GetStartRow(), m_Selection.GetStartChannel());
}
return true;
}
// Get the velocity at which a given note would be played
int CViewPattern::GetDefaultVolume(const ModCommand &m, ModCommand::INSTR lastInstr) const
{
const CSoundFile &sndFile = *GetSoundFile();
SAMPLEINDEX sample = GetDocument()->GetSampleIndex(m, lastInstr);
if(sample)
return std::min(sndFile.GetSample(sample).nVolume, uint16(256)) / 4u;
else if(m.instr > 0 && m.instr <= sndFile.GetNumInstruments() && sndFile.Instruments[m.instr] != nullptr && sndFile.Instruments[m.instr]->HasValidMIDIChannel())
return std::min(sndFile.Instruments[m.instr]->nGlobalVol, uint32(64)); // For instrument plugins
else
return 64;
}
int CViewPattern::GetBaseNote() const
{
const CModDoc *modDoc = GetDocument();
INSTRUMENTINDEX instr = static_cast<INSTRUMENTINDEX>(GetCurrentInstrument());
if(!instr && !IsLiveRecord())
instr = GetCursorCommand().instr;
return modDoc->GetBaseNote(instr);
}
ModCommand::NOTE CViewPattern::GetNoteWithBaseOctave(int note) const
{
const CModDoc *modDoc = GetDocument();
INSTRUMENTINDEX instr = static_cast<INSTRUMENTINDEX>(GetCurrentInstrument());
if(!instr && !IsLiveRecord())
instr = GetCursorCommand().instr;
return modDoc->GetNoteWithBaseOctave(note, instr);
}
void CViewPattern::OnDropSelection()
{
CModDoc *pModDoc;
if((pModDoc = GetDocument()) == nullptr || !IsEditingEnabled_bmsg())
{
return;
}
CSoundFile &sndFile = pModDoc->GetSoundFile();
if(!sndFile.Patterns.IsValidPat(m_nPattern))
{
return;
}
// Compute relative movement
int dx = (int)m_DragPos.GetChannel() - (int)m_StartSel.GetChannel();
int dy = (int)m_DragPos.GetRow() - (int)m_StartSel.GetRow();
if((!dx) && (!dy))
{
return;
}
// Allocate replacement pattern
CPattern &pattern = sndFile.Patterns[m_nPattern];
auto origPattern = pattern.GetData();
// Compute destination rect
PatternCursor begin(m_Selection.GetUpperLeft()), end(m_Selection.GetLowerRight());
begin.Move(dy, dx, 0);
if(begin.GetChannel() >= sndFile.GetNumChannels())
{
// Moved outside pattern range.
return;
}
end.Move(dy, dx, 0);
if(end.GetColumnType() == PatternCursor::effectColumn)
{
// Extend to parameter column
end.Move(0, 0, 1);
}
begin.Sanitize(pattern.GetNumRows(), pattern.GetNumChannels());
end.Sanitize(pattern.GetNumRows(), pattern.GetNumChannels());
PatternRect destination(begin, end);
const bool moveSelection = !m_Status[psKeyboardDragSelect | psCtrlDragSelect];
BeginWaitCursor();
pModDoc->GetPatternUndo().PrepareUndo(m_nPattern, 0, 0, sndFile.GetNumChannels(), pattern.GetNumRows(), moveSelection ? "Move Selection" : "Copy Selection");
const ModCommand empty = ModCommand::Empty();
auto p = pattern.begin();
for(ROWINDEX row = 0; row < pattern.GetNumRows(); row++)
{
for(CHANNELINDEX chn = 0; chn < sndFile.GetNumChannels(); chn++, p++)
{
for(int c = PatternCursor::firstColumn; c <= PatternCursor::lastColumn; c++)
{
PatternCursor cell(row, chn, static_cast<PatternCursor::Columns>(c));
int xsrc = chn, ysrc = row;
if(destination.Contains(cell))
{
// Current cell is from destination selection
xsrc -= dx;
ysrc -= dy;
} else if(m_Selection.Contains(cell))
{
// Current cell is from source rectangle (clear)
if(moveSelection)
{
xsrc = -1;
}
} else
{
continue;
}
// Copy the data
const ModCommand &src = (xsrc >= 0 && xsrc < (int)sndFile.GetNumChannels() && ysrc >= 0 && ysrc < (int)sndFile.Patterns[m_nPattern].GetNumRows()) ? origPattern[ysrc * sndFile.GetNumChannels() + xsrc] : empty;
switch(c)
{
case PatternCursor::noteColumn:
p->note = src.note;
break;
case PatternCursor::instrColumn:
p->instr = src.instr;
break;
case PatternCursor::volumeColumn:
p->vol = src.vol;
p->volcmd = src.volcmd;
break;
case PatternCursor::effectColumn:
p->command = src.command;
p->param = src.param;
break;
}
}
}
}
// Fix: Horizontal scrollbar pos screwed when selecting with mouse
SetCursorPosition(begin);
SetCurSel(destination);
InvalidatePattern();
SetModified(false);
EndWaitCursor();
}
void CViewPattern::OnSetSelInstrument()
{
SetSelectionInstrument(static_cast<INSTRUMENTINDEX>(GetCurrentInstrument()), false);
}
void CViewPattern::OnRemoveChannelDialog()
{
CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr)
return;
pModDoc->ChangeNumChannels(0);
SetCurrentPattern(m_nPattern); //Updating the screen.
}
void CViewPattern::OnRemoveChannel()
{
CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr)
return;
const CSoundFile &sndFile = pModDoc->GetSoundFile();
if(sndFile.GetNumChannels() <= sndFile.GetModSpecifications().channelsMin)
{
Reporting::Error("No channel removed - channel number already at minimum.", "Remove channel");
return;
}
CHANNELINDEX nChn = m_MenuCursor.GetChannel();
const bool isEmpty = pModDoc->IsChannelUnused(nChn);
CString str;
str.Format(_T("Remove channel %d? This channel still contains note data!"), nChn + 1);
if(isEmpty || Reporting::Confirm(str, "Remove channel") == cnfYes)
{
std::vector<bool> keepMask(pModDoc->GetNumChannels(), true);
keepMask[nChn] = false;
pModDoc->RemoveChannels(keepMask, true);
SetCurrentPattern(m_nPattern); //Updating the screen.
pModDoc->UpdateAllViews(nullptr, GeneralHint().General().Channels(), this);
}
}
void CViewPattern::AddChannel(CHANNELINDEX parent, bool afterCurrent)
{
CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr)
return;
BeginWaitCursor();
// Create new channel order, with channel nBefore being an invalid (and thus empty) channel.
std::vector<CHANNELINDEX> channels(pModDoc->GetNumChannels() + 1, CHANNELINDEX_INVALID);
CHANNELINDEX i = 0;
for(CHANNELINDEX nChn = 0; nChn < pModDoc->GetNumChannels() + 1; nChn++)
{
if(nChn != (parent + (afterCurrent ? 1 : 0)))
{
channels[nChn] = i++;
}
}
if(pModDoc->ReArrangeChannels(channels) != CHANNELINDEX_INVALID)
{
auto &chnSettings = pModDoc->GetSoundFile().ChnSettings;
chnSettings[parent + (afterCurrent ? 1 : 0)].color = chnSettings[parent + (afterCurrent ? 0 : 1)].color;
pModDoc->SetModified();
pModDoc->UpdateAllViews(nullptr, GeneralHint().General().Channels(), this); //refresh channel headers
SetCurrentPattern(m_nPattern);
}
EndWaitCursor();
}
void CViewPattern::OnDuplicateChannel()
{
CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr)
return;
const CHANNELINDEX dupChn = m_MenuCursor.GetChannel();
if(dupChn >= pModDoc->GetNumChannels())
return;
if(!pModDoc->IsChannelUnused(dupChn) && Reporting::Confirm(_T("This affects all patterns, proceed?"), _T("Duplicate Channel")) != cnfYes)
return;
BeginWaitCursor();
// Create new channel order, with channel nDupChn duplicated.
std::vector<CHANNELINDEX> channels(pModDoc->GetNumChannels() + 1, 0);
CHANNELINDEX i = 0;
for(CHANNELINDEX nChn = 0; nChn < pModDoc->GetNumChannels() + 1; nChn++)
{
channels[nChn] = i;
if(nChn != dupChn)
i++;
}
// Check that duplication happened and in that case update.
if(pModDoc->ReArrangeChannels(channels) != CHANNELINDEX_INVALID)
{
pModDoc->SetModified();
pModDoc->UpdateAllViews(nullptr, GeneralHint().General().Channels(), this); //refresh channel headers
SetCurrentPattern(m_nPattern);
}
EndWaitCursor();
}
void CViewPattern::OnRunScript()
{
;
}
void CViewPattern::OnSwitchToOrderList()
{
PostCtrlMessage(CTRLMSG_SETFOCUS);
}
void CViewPattern::OnPrevOrder()
{
PostCtrlMessage(CTRLMSG_PREVORDER);
}
void CViewPattern::OnNextOrder()
{
PostCtrlMessage(CTRLMSG_NEXTORDER);
}
void CViewPattern::OnUpdateUndo(CCmdUI *pCmdUI)
{
CModDoc *pModDoc = GetDocument();
if((pCmdUI) && (pModDoc))
{
pCmdUI->Enable(pModDoc->GetPatternUndo().CanUndo());
pCmdUI->SetText(CMainFrame::GetInputHandler()->GetKeyTextFromCommand(kcEditUndo, _T("Undo ") + pModDoc->GetPatternUndo().GetUndoName()));
}
}
void CViewPattern::OnUpdateRedo(CCmdUI *pCmdUI)
{
CModDoc *pModDoc = GetDocument();
if((pCmdUI) && (pModDoc))
{
pCmdUI->Enable(pModDoc->GetPatternUndo().CanRedo());
pCmdUI->SetText(CMainFrame::GetInputHandler()->GetKeyTextFromCommand(kcEditRedo, _T("Redo ") + pModDoc->GetPatternUndo().GetRedoName()));
}
}
void CViewPattern::OnEditUndo()
{
UndoRedo(true);
}
void CViewPattern::OnEditRedo()
{
UndoRedo(false);
}
void CViewPattern::UndoRedo(bool undo)
{
CModDoc *pModDoc = GetDocument();
if(pModDoc && IsEditingEnabled_bmsg())
{
CHANNELINDEX oldNumChannels = pModDoc->GetNumChannels();
PATTERNINDEX pat = undo ? pModDoc->GetPatternUndo().Undo() : pModDoc->GetPatternUndo().Redo();
const CSoundFile &sndFile = pModDoc->GetSoundFile();
if(pat < sndFile.Patterns.Size())
{
if(pat != m_nPattern)
{
// Find pattern in sequence.
ORDERINDEX matchingOrder = Order().FindOrder(pat, GetCurrentOrder());
if(matchingOrder != ORDERINDEX_INVALID)
{
SetCurrentOrder(matchingOrder);
}
SetCurrentPattern(pat);
} else
{
InvalidatePattern(true, true);
}
SetModified(false);
SanitizeCursor();
UpdateScrollSize();
}
if(oldNumChannels != pModDoc->GetNumChannels())
{
pModDoc->UpdateAllViews(this, GeneralHint().Channels().ModType(), this);
}
}
}
// Apply amplification and fade function to volume
static void AmplifyFade(int &vol, int amp, ROWINDEX row, ROWINDEX numRows, int fadeIn, int fadeOut, Fade::Func &fadeFunc)
{
const bool doFadeIn = fadeIn != amp, doFadeOut = fadeOut != amp;
const double fadeStart = fadeIn / 100.0, fadeStartDiff = (amp - fadeIn) / 100.0;
const double fadeEnd = fadeOut / 100.0, fadeEndDiff = (amp - fadeOut) / 100.0;
double l;
if(doFadeIn && doFadeOut)
{
ROWINDEX numRows2 = numRows / 2;
if(row < numRows2)
l = fadeStart + fadeFunc(static_cast<double>(row) / numRows2) * fadeStartDiff;
else
l = fadeEnd + fadeFunc(static_cast<double>(numRows - row) / (numRows - numRows2)) * fadeEndDiff;
} else if(doFadeIn)
{
l = fadeStart + fadeFunc(static_cast<double>(row + 1) / numRows) * fadeStartDiff;
} else if(doFadeOut)
{
l = fadeEnd + fadeFunc(static_cast<double>(numRows - row) / numRows) * fadeEndDiff;
} else
{
l = amp / 100.0;
}
vol = mpt::saturate_round<int>(vol * l);
Limit(vol, 0, 64);
}
void CViewPattern::OnPatternAmplify()
{
static CAmpDlg::AmpSettings settings{Fade::kLinear, 0, 0, 100, false, false};
CAmpDlg dlg(this, settings, 0);
if(dlg.DoModal() != IDOK)
{
return;
}
CSoundFile &sndFile = *GetSoundFile();
if(!sndFile.Patterns.IsValidPat(m_nPattern))
return;
const bool useVolCol = sndFile.GetModSpecifications().HasVolCommand(VOLCMD_VOLUME);
BeginWaitCursor();
PrepareUndo(m_Selection, "Amplify");
m_Selection.Sanitize(sndFile.Patterns[m_nPattern].GetNumRows(), sndFile.GetNumChannels());
const CHANNELINDEX firstChannel = m_Selection.GetStartChannel(), lastChannel = m_Selection.GetEndChannel();
const ROWINDEX firstRow = m_Selection.GetStartRow(), lastRow = m_Selection.GetEndRow();
// For partically selected start and end channels, we check if the start and end columns contain the relevant columns.
bool firstChannelValid, lastChannelValid;
if(useVolCol)
{
// Volume column
firstChannelValid = m_Selection.ContainsHorizontal(PatternCursor(0, firstChannel, PatternCursor::volumeColumn));
lastChannelValid = m_Selection.ContainsHorizontal(PatternCursor(0, lastChannel, PatternCursor::volumeColumn));
} else
{
// Effect column
firstChannelValid = true; // We cannot start "too far right" in the channel, since this is the last column.
lastChannelValid = m_Selection.GetLowerRight().CompareColumn(PatternCursor(0, lastChannel, PatternCursor::effectColumn)) >= 0;
}
// Adjust min/max channel if they're only partly selected (i.e. volume column or effect column (when using .MOD) is not covered)
// XXX if only the effect column is marked in the XM format, we cannot amplify volume commands there. Does anyone use that?
if((!firstChannelValid && firstChannel >= lastChannel) || (!lastChannelValid && lastChannel <= firstChannel))
{
EndWaitCursor();
return;
}
// Volume memory for each channel.
std::vector<ModCommand::VOL> chvol(lastChannel + 1, 64);
// First, fill the volume memory in case we start the selection before some note
ApplyToSelection([&] (ModCommand &m, ROWINDEX, CHANNELINDEX chn)
{
if((chn == firstChannel && !firstChannelValid) || (chn == lastChannel && !lastChannelValid))
return;
if(m.command == CMD_VOLUME)
chvol[chn] = std::min(m.param, ModCommand::PARAM(64));
else if(m.volcmd == VOLCMD_VOLUME)
chvol[chn] = m.vol;
else if(m.instr != 0)
chvol[chn] = static_cast<ModCommand::VOL>(GetDefaultVolume(m));
});
Fade::Func fadeFunc = GetFadeFunc(settings.fadeLaw);
// Now do the actual amplification
const int cy = lastRow - firstRow + 1; // total rows (for fading)
ApplyToSelection([&] (ModCommand &m, ROWINDEX nRow, CHANNELINDEX chn)
{
if((chn == firstChannel && !firstChannelValid) || (chn == lastChannel && !lastChannelValid))
return;
if(m.command == CMD_VOLUME)
chvol[chn] = std::min(m.param, ModCommand::PARAM(64));
else if(m.volcmd == VOLCMD_VOLUME)
chvol[chn] = m.vol;
else if(m.instr != 0)
chvol[chn] = static_cast<ModCommand::VOL>(GetDefaultVolume(m));
if(settings.fadeIn || settings.fadeOut || (m.IsNote() && m.instr != 0))
{
// Insert new volume commands where necessary
if(useVolCol && m.volcmd == VOLCMD_NONE)
{
m.volcmd = VOLCMD_VOLUME;
m.vol = chvol[chn];
} else if(!useVolCol && m.command == CMD_NONE)
{
m.command = CMD_VOLUME;
m.param = chvol[chn];
}
}
if(m.volcmd == VOLCMD_VOLUME)
{
int vol = m.vol;
AmplifyFade(vol, settings.factor, nRow - firstRow, cy, settings.fadeIn ? settings.fadeInStart : settings.factor, settings.fadeOut ? settings.fadeOutEnd : settings.factor, fadeFunc);
m.vol = static_cast<ModCommand::VOL>(vol);
}
if(m_Selection.ContainsHorizontal(PatternCursor(0, chn, PatternCursor::effectColumn)) || m_Selection.ContainsHorizontal(PatternCursor(0, chn, PatternCursor::paramColumn)))
{
if(m.command == CMD_VOLUME && m.param <= 64)
{
int vol = m.param;
AmplifyFade(vol, settings.factor, nRow - firstRow, cy, settings.fadeIn ? settings.fadeInStart : settings.factor, settings.fadeOut ? settings.fadeOutEnd : settings.factor, fadeFunc);
m.param = static_cast<ModCommand::PARAM>(vol);
}
}
});
SetModified(false);
InvalidateSelection();
EndWaitCursor();
}
LRESULT CViewPattern::OnPlayerNotify(Notification *pnotify)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || pnotify == nullptr)
{
return 0;
}
if(pnotify->type[Notification::Position])
{
ORDERINDEX ord = pnotify->order;
ROWINDEX row = pnotify->row;
PATTERNINDEX pat = pnotify->pattern;
bool updateOrderList = false;
if(m_nLastPlayedOrder != ord)
{
updateOrderList = true;
m_nLastPlayedOrder = ord;
}
if(row < m_nLastPlayedRow)
{
InvalidateChannelsHeaders();
}
m_nLastPlayedRow = row;
if(!pSndFile->m_SongFlags[SONG_PAUSED | SONG_STEP])
{
const auto &order = Order();
if(ord >= order.GetLength() || order[ord] != pat)
{
//order doesn't correlate with pattern, so mark it as invalid
ord = ORDERINDEX_INVALID;
}
if(m_pEffectVis && m_pEffectVis->m_hWnd)
{
m_pEffectVis->SetPlayCursor(pat, row);
}
// Simple detection of backwards-going patterns to avoid jerky animation
m_nNextPlayRow = ROWINDEX_INVALID;
if((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_SMOOTHSCROLL) && pSndFile->Patterns.IsValidPat(pat) && pSndFile->Patterns[pat].IsValidRow(row))
{
for(const ModCommand *m = pSndFile->Patterns[pat].GetRow(row), *mEnd = m + pSndFile->GetNumChannels(); m != mEnd; m++)
{
if(m->command == CMD_PATTERNBREAK)
m_nNextPlayRow = m->param;
else if(m->command == CMD_POSITIONJUMP && (m_nNextPlayRow == ROWINDEX_INVALID || pSndFile->GetType() == MOD_TYPE_XM))
m_nNextPlayRow = 0;
}
}
if(m_nNextPlayRow == ROWINDEX_INVALID)
m_nNextPlayRow = row + 1;
m_nTicksOnRow = pnotify->ticksOnRow;
SetPlayCursor(pat, row, pnotify->tick);
// Don't follow song if user drags selections or scrollbars.
if((m_Status & (psFollowSong | psDragActive)) == psFollowSong)
{
if(pat < pSndFile->Patterns.Size())
{
if(pat != m_nPattern || ord != m_nOrder || updateOrderList)
{
if(pat != m_nPattern)
SetCurrentPattern(pat, row);
else if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_SHOWPREVIOUS)
InvalidatePattern(true, true); // Redraw previous / next pattern
if(ord < order.GetLength())
{
m_nOrder = ord;
SendCtrlMessage(CTRLMSG_NOTIFYCURRENTORDER, ord);
}
updateOrderList = false;
}
if(row != GetCurrentRow())
{
SetCurrentRow((row < pSndFile->Patterns[pat].GetNumRows()) ? row : 0, false, false);
}
}
} else
{
if(updateOrderList)
{
SendCtrlMessage(CTRLMSG_FORCEREFRESH); //force orderlist refresh
updateOrderList = false;
}
}
}
}
if(pnotify->type[Notification::VUMeters | Notification::Stop] && m_Status[psShowVUMeters])
{
UpdateAllVUMeters(pnotify);
}
if(pnotify->type[Notification::Stop])
{
m_baPlayingNote.reset();
ChnVUMeters.fill(0); // Also zero all non-visible VU meters
SetPlayCursor(PATTERNINDEX_INVALID, ROWINDEX_INVALID, 0);
}
UpdateIndicator(false);
return 0;
}
// record plugin parameter changes into current pattern
LRESULT CViewPattern::OnRecordPlugParamChange(WPARAM plugSlot, LPARAM paramIndex)
{
CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr || !IsEditingEnabled())
return 0;
CSoundFile &sndFile = pModDoc->GetSoundFile();
//Work out where to put the new data
const PatternEditPos editPos = GetEditPos(sndFile, IsLiveRecord());
const CHANNELINDEX chn = editPos.channel;
const ROWINDEX row = editPos.row;
const PATTERNINDEX pattern = editPos.pattern;
ModCommand &mSrc = *sndFile.Patterns[pattern].GetpModCommand(row, chn);
ModCommand m = mSrc;
// TODO: Is the right plugin active? Move to a chan with the right plug
// Probably won't do this - finish fluctuator implementation instead.
IMixPlugin *pPlug = sndFile.m_MixPlugins[plugSlot].pMixPlugin;
if(pPlug == nullptr)
return 0;
if(sndFile.GetModSpecifications().HasNote(NOTE_PCS))
{
// MPTM: Use PC Notes
// only overwrite existing PC Notes
if(m.IsEmpty() || m.IsPcNote())
{
m.Set(NOTE_PCS, static_cast<ModCommand::INSTR>(plugSlot + 1), static_cast<uint16>(paramIndex), static_cast<uint16>(pPlug->GetParameter(static_cast<PlugParamIndex>(paramIndex)) * ModCommand::maxColumnValue));
}
} else if(sndFile.GetModSpecifications().HasCommand(CMD_SMOOTHMIDI))
{
// Other formats: Use MIDI macros
// Figure out which plug param (if any) is controllable using the active macro on this channel.
int activePlugParam = -1;
auto activeMacro = sndFile.m_PlayState.Chn[chn].nActiveMacro;
if(sndFile.m_MidiCfg.GetParameteredMacroType(activeMacro) == kSFxPlugParam)
activePlugParam = sndFile.m_MidiCfg.MacroToPlugParam(activeMacro);
// If the wrong macro is active, see if we can find the right one.
// If we can, activate it for this chan by writing appropriate SFx command it.
if(activePlugParam != paramIndex)
{
int foundMacro = sndFile.m_MidiCfg.FindMacroForParam(static_cast<PlugParamIndex>(paramIndex));
if(foundMacro >= 0)
{
sndFile.m_PlayState.Chn[chn].nActiveMacro = static_cast<uint8>(foundMacro);
if(m.command == CMD_NONE || m.command == CMD_SMOOTHMIDI || m.command == CMD_MIDI) //we overwrite existing Zxx and \xx only.
{
m.command = CMD_S3MCMDEX;
if(!sndFile.GetModSpecifications().HasCommand(CMD_S3MCMDEX))
m.command = CMD_MODCMDEX;
m.param = 0xF0 | (foundMacro & 0x0F);
}
}
}
// Write the data, but we only overwrite if the command is a macro anyway.
if(m.command == CMD_NONE || m.command == CMD_SMOOTHMIDI || m.command == CMD_MIDI)
{
m.command = CMD_SMOOTHMIDI;
PlugParamValue param = pPlug->GetParameter(static_cast<PlugParamIndex>(paramIndex));
Limit(param, 0.0f, 1.0f);
m.param = static_cast<ModCommand::PARAM>(param * 127.0f);
}
}
if(m != mSrc)
{
pModDoc->GetPatternUndo().PrepareUndo(pattern, chn, row, 1, 1, "Automation Entry");
mSrc = m;
InvalidateCell(PatternCursor(row, chn));
SetModified(false);
}
return 0;
}
PatternEditPos CViewPattern::GetEditPos(const CSoundFile &sndFile, const bool liveRecord) const
{
PatternEditPos editPos;
if(liveRecord)
{
if(m_nPlayPat != PATTERNINDEX_INVALID)
{
editPos.row = m_nPlayRow;
editPos.order = GetCurrentOrder();
editPos.pattern = m_nPlayPat;
} else
{
editPos.row = sndFile.m_PlayState.m_nRow;
editPos.order = sndFile.m_PlayState.m_nCurrentOrder;
editPos.pattern = sndFile.m_PlayState.m_nPattern;
}
if(!sndFile.Patterns.IsValidPat(editPos.pattern) || !sndFile.Patterns[editPos.pattern].IsValidRow(editPos.row))
{
editPos.row = GetCurrentRow();
editPos.order = GetCurrentOrder();
editPos.pattern = m_nPattern;
}
const auto &order = Order();
if(!order.IsValidPat(editPos.order) || order[editPos.order] != editPos.pattern)
{
ORDERINDEX realOrder = order.FindOrder(editPos.pattern, editPos.order);
if(realOrder != ORDERINDEX_INVALID)
editPos.order = realOrder;
}
} else
{
editPos.row = GetCurrentRow();
editPos.order = GetCurrentOrder();
editPos.pattern = m_nPattern;
}
editPos.channel = GetCurrentChannel();
return editPos;
}
// Return ModCommand at the given cursor position of the current pattern.
// If the position is not valid, a pointer to a dummy command is returned.
ModCommand &CViewPattern::GetModCommand(PatternCursor cursor)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr && pSndFile->Patterns.IsValidPat(GetCurrentPattern()) && pSndFile->Patterns[GetCurrentPattern()].IsValidRow(cursor.GetRow()))
{
return *pSndFile->Patterns[GetCurrentPattern()].GetpModCommand(cursor.GetRow(), cursor.GetChannel());
}
// Failed.
static ModCommand dummy;
return dummy;
}
// Sanitize cursor so that it can't point to an invalid position in the current pattern.
void CViewPattern::SanitizeCursor()
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr && pSndFile->Patterns.IsValidPat(GetCurrentPattern()))
{
m_Cursor.Sanitize(GetSoundFile()->Patterns[m_nPattern].GetNumRows(), GetSoundFile()->Patterns[m_nPattern].GetNumChannels());
}
};
// Returns pointer to modcommand at given position.
// If the position is not valid, a pointer to a dummy command is returned.
ModCommand &CViewPattern::GetModCommand(CSoundFile &sndFile, const PatternEditPos &pos)
{
static ModCommand dummy;
if(sndFile.Patterns.IsValidPat(pos.pattern) && pos.row < sndFile.Patterns[pos.pattern].GetNumRows() && pos.channel < sndFile.GetNumChannels())
return *sndFile.Patterns[pos.pattern].GetpModCommand(pos.row, pos.channel);
else
return dummy;
}
LRESULT CViewPattern::OnMidiMsg(WPARAM dwMidiDataParam, LPARAM)
{
const uint32 midiData = static_cast<uint32>(dwMidiDataParam);
static uint8 midiVolume = 127;
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr || pMainFrm == nullptr)
return 0;
CSoundFile &sndFile = pModDoc->GetSoundFile();
//Midi message from our perspective:
// +---------------------------+---------------------------+-------------+-------------+
//bit: | 24.23.22.21 | 20.19.18.17 | 16.15.14.13 | 12.11.10.09 | 08.07.06.05 | 04.03.02.01 |
// +---------------------------+---------------------------+-------------+-------------+
// | Velocity (0-127) | Note (middle C is 60) | Event | Channel |
// +---------------------------+---------------------------+-------------+-------------+
//(http://home.roadrunner.com/~jgglatt/tech/midispec.htm)
//Notes:
//. Initial midi data handling is done in MidiInCallBack().
//. If no event is received, previous event is assumed.
//. A note-on (event=9) with velocity 0 is equivalent to a note off.
//. Basing the event solely on the velocity as follows is incorrect,
// since a note-off can have a velocity too:
// BYTE event = (dwMidiData>>16) & 0x64;
//. Sample- and instrumentview handle midi mesages in their own methods.
const uint8 midiByte1 = MIDIEvents::GetDataByte1FromEvent(midiData);
const uint8 midiByte2 = MIDIEvents::GetDataByte2FromEvent(midiData);
const uint8 channel = MIDIEvents::GetChannelFromEvent(midiData);
const uint8 nNote = midiByte1 + NOTE_MIN;
int vol = midiByte2; // At this stage nVol is a non linear value in [0;127]
// Need to convert to linear in [0;64] - see below
MIDIEvents::EventType event = MIDIEvents::GetTypeFromEvent(midiData);
if((event == MIDIEvents::evNoteOn) && !vol)
event = MIDIEvents::evNoteOff; //Convert event to note-off if req'd
// Handle MIDI mapping.
PLUGINDEX mappedIndex = uint8_max;
PlugParamIndex paramIndex = 0;
uint16 paramValue = uint16_max;
bool captured = sndFile.GetMIDIMapper().OnMIDImsg(midiData, mappedIndex, paramIndex, paramValue);
// Handle MIDI messages assigned to shortcuts
CInputHandler *ih = CMainFrame::GetInputHandler();
if(ih->HandleMIDIMessage(static_cast<InputTargetContext>(kCtxViewPatterns + 1 + m_Cursor.GetColumnType()), midiData) != kcNull
|| ih->HandleMIDIMessage(kCtxAllContexts, midiData) != kcNull)
{
// Mapped to a command, no need to pass message on.
captured = true;
}
// Write parameter control commands if needed.
if(paramValue != uint16_max && IsEditingEnabled() && sndFile.GetType() == MOD_TYPE_MPT)
{
const bool liveRecord = IsLiveRecord();
PatternEditPos editPos = GetEditPos(sndFile, liveRecord);
ModCommand &m = GetModCommand(sndFile, editPos);
pModDoc->GetPatternUndo().PrepareUndo(editPos.pattern, editPos.channel, editPos.row, 1, 1, "MIDI Mapping Record");
m.Set(NOTE_PCS, mappedIndex, static_cast<uint16>(paramIndex), static_cast<uint16>((paramValue * ModCommand::maxColumnValue) / 16383));
if(!liveRecord)
InvalidateRow(editPos.row);
pModDoc->SetModified();
pModDoc->UpdateAllViews(this, PatternHint(editPos.pattern).Data(), this);
}
if(captured)
{
// Event captured by MIDI mapping or shortcut, no need to pass message on.
return 1;
}
const auto &modSpecs = sndFile.GetModSpecifications();
bool recordParamAsZxx = false;
switch(event)
{
case MIDIEvents::evNoteOff: // Note Off
if(m_midiSustainActive[channel])
{
m_midiSustainBuffer[channel].push_back(midiData);
return 1;
}
// The following method takes care of:
// . Silencing specific active notes (just setting nNote to 255 as was done before is not acceptible)
// . Entering a note off in pattern if required
TempStopNote(nNote, ((TrackerSettings::Instance().m_dwMidiSetup & MIDISETUP_RECORDNOTEOFF) != 0));
break;
case MIDIEvents::evNoteOn: // Note On
// Continue playing as soon as MIDI notes are being received
if((pMainFrm->GetSoundFilePlaying() != &sndFile || sndFile.IsPaused()) && (TrackerSettings::Instance().m_dwMidiSetup & MIDISETUP_PLAYPATTERNONMIDIIN))
pModDoc->OnPatternPlayNoLoop();
vol = CMainFrame::ApplyVolumeRelatedSettings(midiData, midiVolume);
if(vol < 0)
vol = -1;
else
vol = (vol + 3) / 4; //Value from [0,256] to [0,64]
TempEnterNote(nNote, vol, true);
break;
case MIDIEvents::evPolyAftertouch: // Polyphonic aftertouch
EnterAftertouch(nNote, vol);
break;
case MIDIEvents::evChannelAftertouch: // Channel aftertouch
EnterAftertouch(NOTE_NONE, midiByte1);
break;
case MIDIEvents::evPitchBend: // Pitch wheel
recordParamAsZxx = (TrackerSettings::Instance().m_dwMidiSetup & MIDISETUP_MIDIMACROPITCHBEND) != 0 || modSpecs.HasCommand(CMD_FINETUNE);
break;
case MIDIEvents::evControllerChange: //Controller change
// Checking whether to record MIDI controller change as MIDI macro change.
// Don't write this if command was already written by MIDI mapping.
if((paramValue == uint16_max || sndFile.GetType() != MOD_TYPE_MPT)
&& (TrackerSettings::Instance().m_dwMidiSetup & MIDISETUP_MIDIMACROCONTROL)
&& !TrackerSettings::Instance().midiIgnoreCCs.Get()[midiByte1 & 0x7F])
{
recordParamAsZxx = true;
}
switch(midiByte1)
{
case MIDIEvents::MIDICC_Volume_Coarse:
midiVolume = midiByte2;
break;
case MIDIEvents::MIDICC_HoldPedal_OnOff:
m_midiSustainActive[channel] = (midiByte2 >= 0x40);
if(!m_midiSustainActive[channel])
{
// Release all notes
for(const auto offEvent : m_midiSustainBuffer[channel])
{
OnMidiMsg(offEvent, 0);
}
m_midiSustainBuffer[channel].clear();
}
recordParamAsZxx = false;
break;
}
break;
case MIDIEvents::evSystem:
if(TrackerSettings::Instance().m_dwMidiSetup & MIDISETUP_RESPONDTOPLAYCONTROLMSGS)
{
// Respond to MIDI song messages
switch(channel)
{
case MIDIEvents::sysStart: //Start song
pModDoc->OnPlayerPlayFromStart();
break;
case MIDIEvents::sysContinue: //Continue song
pModDoc->OnPlayerPlay();
break;
case MIDIEvents::sysStop: //Stop song
pModDoc->OnPlayerStop();
break;
}
}
break;
}
// Write CC or pitch bend message as MIDI macro change.
if(recordParamAsZxx && IsEditingEnabled())
{
const bool liveRecord = IsLiveRecord();
const auto editpos = GetEditPos(sndFile, liveRecord);
ModCommand &m = GetModCommand(sndFile, editpos);
bool update = false;
if(event == MIDIEvents::evPitchBend && (m.command == CMD_NONE || m.command == CMD_FINETUNE || m.command == CMD_FINETUNE_SMOOTH) && modSpecs.HasCommand(CMD_FINETUNE))
{
pModDoc->GetPatternUndo().PrepareUndo(editpos.pattern, editpos.channel, editpos.row, 1, 1, "MIDI Record Entry");
m.command = (m.command == CMD_NONE) ? CMD_FINETUNE : CMD_FINETUNE_SMOOTH;
m.param = (midiByte2 << 1) | (midiByte1 >> 7);
update = true;
} else if(m.IsPcNote())
{
pModDoc->GetPatternUndo().PrepareUndo(editpos.pattern, editpos.channel, editpos.row, 1, 1, "MIDI Record Entry");
m.SetValueEffectCol(static_cast<decltype(m.GetValueEffectCol())>(Util::muldivr(midiByte2, ModCommand::maxColumnValue, 127)));
update = true;
} else if((m.command == CMD_NONE || m.command == CMD_SMOOTHMIDI || m.command == CMD_MIDI)
&& (modSpecs.HasCommand(CMD_SMOOTHMIDI) || modSpecs.HasCommand(CMD_MIDI)))
{
// Write command only if there's no existing command or already a midi macro command.
pModDoc->GetPatternUndo().PrepareUndo(editpos.pattern, editpos.channel, editpos.row, 1, 1, "MIDI Record Entry");
m.command = modSpecs.HasCommand(CMD_SMOOTHMIDI) ? CMD_SMOOTHMIDI : CMD_MIDI;
m.param = midiByte2;
update = true;
}
if(update)
{
pModDoc->SetModified();
pModDoc->UpdateAllViews(this, PatternHint(editpos.pattern).Data(), this);
// Update GUI only if not recording live.
if(!liveRecord)
InvalidateRow(editpos.row);
}
}
// Pass MIDI to plugin
if(TrackerSettings::Instance().m_dwMidiSetup & MIDISETUP_MIDITOPLUG
&& pMainFrm->GetModPlaying() == pModDoc
&& event != MIDIEvents::evNoteOn
&& event != MIDIEvents::evNoteOff)
{
const INSTRUMENTINDEX instr = static_cast<INSTRUMENTINDEX>(GetCurrentInstrument());
IMixPlugin *plug = sndFile.GetInstrumentPlugin(instr);
if(plug)
{
plug->MidiSend(midiData);
// Sending MIDI may modify the plugin. For now, if MIDI data
// is not active sensing, set modified.
if(midiData != MIDIEvents::System(MIDIEvents::sysActiveSense))
pModDoc->SetModified();
}
}
return 1;
}
LRESULT CViewPattern::OnModViewMsg(WPARAM wParam, LPARAM lParam)
{
switch(wParam)
{
case VIEWMSG_SETCTRLWND:
m_hWndCtrl = (HWND)lParam;
m_nOrder = static_cast<ORDERINDEX>(SendCtrlMessage(CTRLMSG_GETCURRENTORDER));
SetCurrentPattern(static_cast<PATTERNINDEX>(SendCtrlMessage(CTRLMSG_GETCURRENTPATTERN)));
break;
case VIEWMSG_GETCURRENTPATTERN:
return m_nPattern;
case VIEWMSG_SETCURRENTPATTERN:
m_nOrder = static_cast<ORDERINDEX>(SendCtrlMessage(CTRLMSG_GETCURRENTORDER));
SetCurrentPattern(static_cast<PATTERNINDEX>(lParam));
break;
case VIEWMSG_GETCURRENTPOS:
return (m_nPattern << 16) | GetCurrentRow();
case VIEWMSG_FOLLOWSONG:
m_Status.reset(psFollowSong);
if(lParam)
{
CModDoc *pModDoc = GetDocument();
m_Status.set(psFollowSong);
if(pModDoc)
pModDoc->SetNotifications(Notification::Position | Notification::VUMeters);
if(pModDoc)
pModDoc->SetFollowWnd(m_hWnd);
SetFocus();
} else
{
InvalidateRow();
}
break;
case VIEWMSG_PATTERNLOOP:
SendCtrlMessage(CTRLMSG_PAT_LOOP, lParam);
break;
case VIEWMSG_SETRECORD:
m_Status.set(psRecordingEnabled, !!lParam);
break;
case VIEWMSG_SETSPACING:
m_nSpacing = static_cast<UINT>(lParam);
break;
case VIEWMSG_PATTERNPROPERTIES:
ShowPatternProperties(static_cast<PATTERNINDEX>(lParam));
GetParentFrame()->SetActiveView(this);
break;
case VIEWMSG_SETVUMETERS:
m_Status.set(psShowVUMeters, !!lParam);
UpdateSizes();
UpdateScrollSize();
InvalidatePattern(true, true);
break;
case VIEWMSG_SETPLUGINNAMES:
m_Status.set(psShowPluginNames, !!lParam);
UpdateSizes();
UpdateScrollSize();
InvalidatePattern(true, true);
break;
case VIEWMSG_DOMIDISPACING:
if(m_nSpacing)
{
int temp = timeGetTime();
if(temp - lParam >= 60)
{
CModDoc *pModDoc = GetDocument();
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
if(!m_Status[psFollowSong]
|| (pMainFrm->GetFollowSong(pModDoc) != m_hWnd)
|| (pModDoc->GetSoundFile().IsPaused()))
{
SetCurrentRow(GetCurrentRow() + m_nSpacing);
}
} else
{
Sleep(0);
PostMessage(WM_MOD_VIEWMSG, VIEWMSG_DOMIDISPACING, lParam);
}
}
break;
case VIEWMSG_LOADSTATE:
if(lParam)
{
PATTERNVIEWSTATE *pState = (PATTERNVIEWSTATE *)lParam;
if(pState->nDetailLevel != PatternCursor::firstColumn)
m_nDetailLevel = pState->nDetailLevel;
if(pState->initialized)
{
SetCurrentPattern(pState->nPattern);
// Fix: Horizontal scrollbar pos screwed when selecting with mouse
SetCursorPosition(pState->cursor);
SetCurSel(pState->selection);
}
}
break;
case VIEWMSG_SAVESTATE:
if(lParam)
{
PATTERNVIEWSTATE *pState = (PATTERNVIEWSTATE *)lParam;
pState->initialized = true;
pState->nPattern = m_nPattern;
pState->cursor = m_Cursor;
pState->selection = m_Selection;
pState->nDetailLevel = m_nDetailLevel;
pState->nOrder = GetCurrentOrder();
}
break;
case VIEWMSG_EXPANDPATTERN:
{
CModDoc *pModDoc = GetDocument();
if(pModDoc->ExpandPattern(m_nPattern))
{
m_Cursor.SetRow(m_Cursor.GetRow() * 2);
SetCurrentPattern(m_nPattern);
}
break;
}
case VIEWMSG_SHRINKPATTERN:
{
CModDoc *pModDoc = GetDocument();
if(pModDoc->ShrinkPattern(m_nPattern))
{
m_Cursor.SetRow(m_Cursor.GetRow() / 2);
SetCurrentPattern(m_nPattern);
}
break;
}
case VIEWMSG_COPYPATTERN:
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr && pSndFile->Patterns.IsValidPat(m_nPattern))
{
CopyPattern(m_nPattern, PatternRect(PatternCursor(0, 0), PatternCursor(pSndFile->Patterns[m_nPattern].GetNumRows() - 1, pSndFile->GetNumChannels() - 1, PatternCursor::lastColumn)));
}
break;
}
case VIEWMSG_PASTEPATTERN:
PastePattern(m_nPattern, PatternCursor(0), PatternClipboard::pmOverwrite);
InvalidatePattern();
break;
case VIEWMSG_AMPLIFYPATTERN:
OnPatternAmplify();
break;
case VIEWMSG_SETDETAIL:
if(lParam != m_nDetailLevel)
{
m_nDetailLevel = static_cast<PatternCursor::Columns>(lParam);
UpdateSizes();
UpdateScrollSize();
SetCurrentColumn(m_Cursor);
InvalidatePattern(true, true);
}
break;
case VIEWMSG_DOSCROLL:
OnMouseWheel(0, static_cast<short>(lParam), CPoint(0, 0));
break;
default:
return CModScrollView::OnModViewMsg(wParam, lParam);
}
return 0;
}
void CViewPattern::CursorJump(int distance, bool snap)
{
ROWINDEX row = GetCurrentRow();
const bool upwards = distance < 0;
const int distanceAbs = std::abs(distance);
if(snap && distanceAbs)
// cppcheck false-positive
// cppcheck-suppress signConversion
row = (((row + (upwards ? -1 : 0)) / distanceAbs) + (upwards ? 0 : 1)) * distanceAbs;
else
row += distance;
row = SetCurrentRow(row, true);
if(IsLiveRecord() && !m_Status[psDragActive])
{
CriticalSection cs;
CSoundFile &sndFile = GetDocument()->GetSoundFile();
if(m_nOrder != sndFile.m_PlayState.m_nCurrentOrder)
{
// We jumped to a different order
sndFile.ResetChannels();
sndFile.StopAllVsti();
}
sndFile.m_PlayState.m_nCurrentOrder = sndFile.m_PlayState.m_nNextOrder = GetCurrentOrder();
sndFile.m_PlayState.m_nPattern = m_nPattern;
sndFile.m_PlayState.m_nRow = m_nPlayRow = row;
sndFile.m_PlayState.m_nNextRow = m_nNextPlayRow = row + 1;
// Queue the correct follow-up pattern if we just jumped to the last row.
if(sndFile.Patterns.IsValidPat(m_nPattern) && m_nNextPlayRow >= sndFile.Patterns[m_nPattern].GetNumRows())
{
sndFile.m_PlayState.m_nNextOrder++;
}
CMainFrame::GetMainFrame()->ResetNotificationBuffer();
} else
{
if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_PLAYNAVIGATEROW)
{
PatternStep(row);
}
}
}
LRESULT CViewPattern::OnCustomKeyMsg(WPARAM wParam, LPARAM lParam)
{
CModDoc *pModDoc = GetDocument();
if(!pModDoc)
return kcNull;
CSoundFile &sndFile = pModDoc->GetSoundFile();
switch(wParam)
{
case kcPrevInstrument: OnPrevInstrument(); return wParam;
case kcNextInstrument: OnNextInstrument(); return wParam;
case kcPrevOrder: OnPrevOrder(); return wParam;
case kcNextOrder: OnNextOrder(); return wParam;
case kcPatternPlayRow: OnPatternStep(); return wParam;
case kcPatternRecord: OnPatternRecord(); return wParam;
case kcCursorCopy: OnCursorCopy(); return wParam;
case kcCursorPaste: OnCursorPaste(); return wParam;
case kcChannelMute: for(CHANNELINDEX c = m_Selection.GetStartChannel(); c <= m_Selection.GetEndChannel(); c++)
OnMuteChannel(c);
return wParam;
case kcChannelSolo: OnSoloChannel(GetCurrentChannel()); return wParam;
case kcChannelUnmuteAll: OnUnmuteAll(); return wParam;
case kcToggleChanMuteOnPatTransition: for(CHANNELINDEX c = m_Selection.GetStartChannel(); c <= m_Selection.GetEndChannel(); c++)
TogglePendingMute(c);
return wParam;
case kcUnmuteAllChnOnPatTransition: OnPendingUnmuteAllChnFromClick(); return wParam;
case kcChannelRecordSelect: for(CHANNELINDEX c = m_Selection.GetStartChannel(); c <= m_Selection.GetEndChannel(); c++)
pModDoc->ToggleChannelRecordGroup(c, RecordGroup::Group1);
InvalidateChannelsHeaders(); return wParam;
case kcChannelSplitRecordSelect: for(CHANNELINDEX c = m_Selection.GetStartChannel(); c <= m_Selection.GetEndChannel(); c++)
pModDoc->ToggleChannelRecordGroup(c, RecordGroup::Group2);
InvalidateChannelsHeaders(); return wParam;
case kcChannelReset: for(CHANNELINDEX c = m_Selection.GetStartChannel(); c <= m_Selection.GetEndChannel(); c++)
ResetChannel(m_Cursor.GetChannel());
return wParam;
case kcTimeAtRow: OnShowTimeAtRow(); return wParam;
case kcSoloChnOnPatTransition: PendingSoloChn(GetCurrentChannel()); return wParam;
case kcTransposeUp: OnTransposeUp(); return wParam;
case kcTransposeDown: OnTransposeDown(); return wParam;
case kcTransposeOctUp: OnTransposeOctUp(); return wParam;
case kcTransposeOctDown: OnTransposeOctDown(); return wParam;
case kcTransposeCustom: OnTransposeCustom(); return wParam;
case kcTransposeCustomQuick: OnTransposeCustomQuick(); return wParam;
case kcDataEntryUp: DataEntry(true, false); return wParam;
case kcDataEntryDown: DataEntry(false, false); return wParam;
case kcDataEntryUpCoarse: DataEntry(true, true); return wParam;
case kcDataEntryDownCoarse: DataEntry(false, true); return wParam;
case kcSelectChannel: OnSelectCurrentChannel(); return wParam;
case kcSelectColumn: OnSelectCurrentColumn(); return wParam;
case kcPatternAmplify: OnPatternAmplify(); return wParam;
case kcPatternSetInstrumentNotEmpty:
case kcPatternSetInstrument: SetSelectionInstrument(static_cast<INSTRUMENTINDEX>(GetCurrentInstrument()), wParam == kcPatternSetInstrument); return wParam;
case kcPatternInterpolateNote: OnInterpolateNote(); return wParam;
case kcPatternInterpolateInstr: OnInterpolateInstr(); return wParam;
case kcPatternInterpolateVol: OnInterpolateVolume(); return wParam;
case kcPatternInterpolateEffect: OnInterpolateEffect(); return wParam;
case kcPatternVisualizeEffect: OnVisualizeEffect(); return wParam;
//case kcPatternOpenRandomizer: OnOpenRandomizer(); return wParam;
case kcPatternGrowSelection: OnGrowSelection(); return wParam;
case kcPatternShrinkSelection: OnShrinkSelection(); return wParam;
// Pattern navigation:
case kcPatternJumpUph1Select:
case kcPatternJumpUph1: CursorJump(-(int)GetRowsPerMeasure(), false); return wParam;
case kcPatternJumpDownh1Select:
case kcPatternJumpDownh1: CursorJump(GetRowsPerMeasure(), false); return wParam;
case kcPatternJumpUph2Select:
case kcPatternJumpUph2: CursorJump(-(int)GetRowsPerBeat(), false); return wParam;
case kcPatternJumpDownh2Select:
case kcPatternJumpDownh2: CursorJump(GetRowsPerBeat(), false); return wParam;
case kcPatternSnapUph1Select:
case kcPatternSnapUph1: CursorJump(-(int)GetRowsPerMeasure(), true); return wParam;
case kcPatternSnapDownh1Select:
case kcPatternSnapDownh1: CursorJump(GetRowsPerMeasure(), true); return wParam;
case kcPatternSnapUph2Select:
case kcPatternSnapUph2: CursorJump(-(int)GetRowsPerBeat(), true); return wParam;
case kcPatternSnapDownh2Select:
case kcPatternSnapDownh2: CursorJump(GetRowsPerBeat(), true); return wParam;
case kcNavigateDownSelect:
case kcNavigateDown: CursorJump(1, false); return wParam;
case kcNavigateUpSelect:
case kcNavigateUp: CursorJump(-1, false); return wParam;
case kcNavigateDownBySpacingSelect:
case kcNavigateDownBySpacing: CursorJump(m_nSpacing, false); return wParam;
case kcNavigateUpBySpacingSelect:
case kcNavigateUpBySpacing: CursorJump(-(int)m_nSpacing, false); return wParam;
case kcNavigateLeftSelect:
case kcNavigateLeft:
MoveCursor(false);
return wParam;
case kcNavigateRightSelect:
case kcNavigateRight:
MoveCursor(true);
return wParam;
case kcNavigateNextChanSelect:
case kcNavigateNextChan: SetCurrentColumn((GetCurrentChannel() + 1) % sndFile.GetNumChannels(), m_Cursor.GetColumnType()); return wParam;
case kcNavigatePrevChanSelect:
case kcNavigatePrevChan:{if(GetCurrentChannel() > 0)
SetCurrentColumn((GetCurrentChannel() - 1) % sndFile.GetNumChannels(), m_Cursor.GetColumnType());
else
SetCurrentColumn(sndFile.GetNumChannels() - 1, m_Cursor.GetColumnType());
SetSelToCursor();
return wParam;}
case kcHomeHorizontalSelect:
case kcHomeHorizontal: if (!m_Cursor.IsInFirstColumn()) SetCurrentColumn(0);
else if (GetCurrentRow() > 0) SetCurrentRow(0);
return wParam;
case kcHomeVerticalSelect:
case kcHomeVertical: if (GetCurrentRow() > 0) SetCurrentRow(0);
else if (!m_Cursor.IsInFirstColumn()) SetCurrentColumn(0);
return wParam;
case kcHomeAbsoluteSelect:
case kcHomeAbsolute: if (!m_Cursor.IsInFirstColumn()) SetCurrentColumn(0);
if (GetCurrentRow() > 0) SetCurrentRow(0);
return wParam;
case kcEndHorizontalSelect:
case kcEndHorizontal: if (m_Cursor.CompareColumn(PatternCursor(0, sndFile.GetNumChannels() - 1, m_nDetailLevel)) < 0) SetCurrentColumn(sndFile.GetNumChannels() - 1, m_nDetailLevel);
else if (GetCurrentRow() < pModDoc->GetPatternSize(m_nPattern) - 1) SetCurrentRow(pModDoc->GetPatternSize(m_nPattern) - 1);
return wParam;
case kcEndVerticalSelect:
case kcEndVertical: if (GetCurrentRow() < pModDoc->GetPatternSize(m_nPattern) - 1) SetCurrentRow(pModDoc->GetPatternSize(m_nPattern) - 1);
else if (m_Cursor.CompareColumn(PatternCursor(0, sndFile.GetNumChannels() - 1, m_nDetailLevel)) < 0) SetCurrentColumn(sndFile.GetNumChannels() - 1, m_nDetailLevel);
return wParam;
case kcEndAbsoluteSelect:
case kcEndAbsolute: SetCurrentColumn(sndFile.GetNumChannels() - 1, m_nDetailLevel);
if (GetCurrentRow() < pModDoc->GetPatternSize(m_nPattern) - 1) SetCurrentRow(pModDoc->GetPatternSize(m_nPattern) - 1);
return wParam;
case kcPrevEntryInColumn:
case kcNextEntryInColumn:
JumpToPrevOrNextEntry(wParam == kcNextEntryInColumn, false);
return wParam;
case kcPrevEntryInColumnSelect:
case kcNextEntryInColumnSelect:
JumpToPrevOrNextEntry(wParam == kcNextEntryInColumnSelect, true);
return wParam;
case kcNextPattern: { PATTERNINDEX n = m_nPattern + 1;
while ((n < sndFile.Patterns.Size()) && !sndFile.Patterns.IsValidPat(n)) n++;
SetCurrentPattern((n < sndFile.Patterns.Size()) ? n : 0);
ORDERINDEX currentOrder = GetCurrentOrder();
ORDERINDEX newOrder = Order().FindOrder(m_nPattern, currentOrder, true);
if(newOrder != ORDERINDEX_INVALID)
SetCurrentOrder(newOrder);
return wParam;
}
case kcPrevPattern: { PATTERNINDEX n = (m_nPattern) ? m_nPattern - 1 : sndFile.Patterns.Size() - 1;
while (n > 0 && !sndFile.Patterns.IsValidPat(n)) n--;
SetCurrentPattern(n);
ORDERINDEX currentOrder = GetCurrentOrder();
ORDERINDEX newOrder = Order().FindOrder(m_nPattern, currentOrder, false);
if(newOrder != ORDERINDEX_INVALID)
SetCurrentOrder(newOrder);
return wParam;
}
case kcPrevSequence:
case kcNextSequence:
SendCtrlMessage(CTRLMSG_PAT_SETSEQUENCE, mpt::wrapping_modulo(sndFile.Order.GetCurrentSequenceIndex() + (wParam == kcPrevSequence ? -1 : 1), sndFile.Order.GetNumSequences()));
return wParam;
case kcSelectWithCopySelect:
case kcSelectWithNav:
case kcSelect: if(!m_Status[psDragnDropEdit | psRowSelection | psChannelSelection | psMouseDragSelect]) m_StartSel = m_Cursor;
m_Status.set(psKeyboardDragSelect);
return wParam;
case kcSelectOffWithCopySelect:
case kcSelectOffWithNav:
case kcSelectOff: m_Status.reset(psKeyboardDragSelect | psShiftSelect);
return wParam;
case kcCopySelectWithSelect:
case kcCopySelectWithNav:
case kcCopySelect: if(!m_Status[psDragnDropEdit | psRowSelection | psChannelSelection | psMouseDragSelect]) m_StartSel = m_Cursor;
m_Status.set(psCtrlDragSelect); return wParam;
case kcCopySelectOffWithSelect:
case kcCopySelectOffWithNav:
case kcCopySelectOff: m_Status.reset(psCtrlDragSelect); return wParam;
case kcSelectBeat:
case kcSelectMeasure:
SelectBeatOrMeasure(wParam == kcSelectBeat); return wParam;
case kcSelectEvent: SetCurSel(PatternCursor(m_Selection.GetStartRow(), m_Selection.GetStartChannel(), PatternCursor::firstColumn),
PatternCursor(m_Selection.GetEndRow(), m_Selection.GetEndChannel(), PatternCursor::lastColumn));
return wParam;
case kcSelectRow: SetCurSel(PatternCursor(m_Selection.GetStartRow(), 0, PatternCursor::firstColumn),
PatternCursor(m_Selection.GetEndRow(), sndFile.GetNumChannels(), PatternCursor::lastColumn));
return wParam;
case kcClearRow: OnClearField(RowMask(), false); return wParam;
case kcClearField: OnClearField(RowMask(m_Cursor), false); return wParam;
case kcClearFieldITStyle: OnClearField(RowMask(m_Cursor), false, true); return wParam;
case kcClearRowStep: OnClearField(RowMask(), true); return wParam;
case kcClearFieldStep: OnClearField(RowMask(m_Cursor), true); return wParam;
case kcClearFieldStepITStyle: OnClearField(RowMask(m_Cursor), true, true); return wParam;
case kcDeleteRow: OnDeleteRow(); return wParam;
case kcDeleteWholeRow: OnDeleteWholeRow(); return wParam;
case kcDeleteRowGlobal: OnDeleteRowGlobal(); return wParam;
case kcDeleteWholeRowGlobal: OnDeleteWholeRowGlobal(); return wParam;
case kcInsertRow: OnInsertRow(); return wParam;
case kcInsertWholeRow: OnInsertWholeRow(); return wParam;
case kcInsertRowGlobal: OnInsertRowGlobal(); return wParam;
case kcInsertWholeRowGlobal: OnInsertWholeRowGlobal(); return wParam;
case kcShowNoteProperties: ShowEditWindow(); return wParam;
case kcShowPatternProperties: OnPatternProperties(); return wParam;
case kcShowSplitKeyboardSettings: SetSplitKeyboardSettings(); return wParam;
case kcShowEditMenu:
{
CPoint pt = GetPointFromPosition(m_Cursor);
pt.x += GetChannelWidth() / 2;
pt.y += GetRowHeight() / 2;
OnRButtonDown(0, pt);
}
return wParam;
case kcShowChannelCtxMenu:
{
CPoint pt = GetPointFromPosition(m_Cursor);
pt.x += GetChannelWidth() / 2;
pt.y = (m_szHeader.cy - m_szPluginHeader.cy) / 2;
OnRButtonDown(0, pt);
}
return wParam;
case kcShowChannelPluginCtxMenu:
{
CPoint pt = GetPointFromPosition(m_Cursor);
pt.x += GetChannelWidth() / 2;
pt.y = m_szHeader.cy - m_szPluginHeader.cy / 2;
OnRButtonDown(0, pt);
}
return wParam;
case kcPatternGoto: OnEditGoto(); return wParam;
case kcNoteCut: TempEnterNote(NOTE_NOTECUT); return wParam;
case kcNoteOff: TempEnterNote(NOTE_KEYOFF); return wParam;
case kcNoteFade: TempEnterNote(NOTE_FADE); return wParam;
case kcNotePC: TempEnterNote(NOTE_PC); return wParam;
case kcNotePCS: TempEnterNote(NOTE_PCS); return wParam;
case kcEditUndo: OnEditUndo(); return wParam;
case kcEditRedo: OnEditRedo(); return wParam;
case kcEditFind: OnEditFind(); return wParam;
case kcEditFindNext: OnEditFindNext(); return wParam;
case kcEditCut: OnEditCut(); return wParam;
case kcEditCopy: OnEditCopy(); return wParam;
case kcCopyAndLoseSelection:
OnEditCopy();
[[fallthrough]];
case kcLoseSelection:
SetSelToCursor();
return wParam;
case kcEditPaste: OnEditPaste(); return wParam;
case kcEditMixPaste: OnEditMixPaste(); return wParam;
case kcEditMixPasteITStyle: OnEditMixPasteITStyle(); return wParam;
case kcEditPasteFlood: OnEditPasteFlood(); return wParam;
case kcEditPushForwardPaste: OnEditPushForwardPaste(); return wParam;
case kcEditSelectAll: OnEditSelectAll(); return wParam;
case kcTogglePluginEditor: TogglePluginEditor(GetCurrentChannel()); return wParam;
case kcToggleFollowSong: SendCtrlMessage(CTRLMSG_PAT_FOLLOWSONG, 1); return wParam;
case kcChangeLoopStatus: SendCtrlMessage(CTRLMSG_PAT_LOOP, -1); return wParam;
case kcNewPattern: SendCtrlMessage(CTRLMSG_PAT_NEWPATTERN); return wParam;
case kcDuplicatePattern: SendCtrlMessage(CTRLMSG_PAT_DUPPATTERN); return wParam;
case kcSwitchToOrderList: OnSwitchToOrderList(); return wParam;
case kcToggleOverflowPaste: TrackerSettings::Instance().m_dwPatternSetup ^= PATTERN_OVERFLOWPASTE; return wParam;
case kcToggleNoteOffRecordPC: TrackerSettings::Instance().m_dwPatternSetup ^= PATTERN_KBDNOTEOFF; return wParam;
case kcToggleNoteOffRecordMIDI: TrackerSettings::Instance().m_dwMidiSetup ^= MIDISETUP_RECORDNOTEOFF; return wParam;
case kcPatternEditPCNotePlugin: OnTogglePCNotePluginEditor(); return wParam;
case kcQuantizeSettings: OnSetQuantize(); return wParam;
case kcLockPlaybackToRows: OnLockPatternRows(); return wParam;
case kcFindInstrument: FindInstrument(); return wParam;
case kcChannelSettings:
{
// Open centered Quick Channel Settings dialog.
CRect windowPos;
GetWindowRect(windowPos);
m_quickChannelProperties.Show(GetDocument(), m_Cursor.GetChannel(), CPoint(windowPos.left + windowPos.Width() / 2, windowPos.top + windowPos.Height() / 2));
return wParam;
}
case kcChannelTranspose: m_MenuCursor = m_Cursor; OnTransposeChannel(); return wParam;
case kcChannelDuplicate: m_MenuCursor = m_Cursor; OnDuplicateChannel(); return wParam;
case kcChannelAddBefore: m_MenuCursor = m_Cursor; OnAddChannelFront(); return wParam;
case kcChannelAddAfter: m_MenuCursor = m_Cursor; OnAddChannelAfter(); return wParam;
case kcChannelRemove: m_MenuCursor = m_Cursor; OnRemoveChannel(); return wParam;
case kcChannelMoveLeft:
if(CHANNELINDEX chn = m_Selection.GetStartChannel(); chn > 0)
DragChannel(chn, chn - 1u, m_Selection.GetNumChannels(), false);
return wParam;
case kcChannelMoveRight:
if (CHANNELINDEX chn = m_Selection.GetStartChannel(); chn < sndFile.GetNumChannels() - m_Selection.GetNumChannels())
DragChannel(chn, chn + 1u, m_Selection.GetNumChannels(), false);
return wParam;
case kcSplitPattern: m_MenuCursor = m_Cursor; OnSplitPattern(); return wParam;
case kcDecreaseSpacing:
if(m_nSpacing > 0) SetSpacing(m_nSpacing - 1);
return wParam;
case kcIncreaseSpacing:
if(m_nSpacing < MAX_SPACING) SetSpacing(m_nSpacing + 1);
return wParam;
case kcChordEditor:
{
CChordEditor dlg(this);
dlg.DoModal();
return wParam;
}
// Clipboard Manager
case kcToggleClipboardManager:
PatternClipboardDialog::Toggle();
return wParam;
case kcClipboardPrev:
PatternClipboard::CycleBackward();
PatternClipboardDialog::UpdateList();
return wParam;
case kcClipboardNext:
PatternClipboard::CycleForward();
PatternClipboardDialog::UpdateList();
return wParam;
case kcCutPatternChannel:
PatternClipboard::Copy(sndFile, GetCurrentPattern(), GetCurrentChannel());
OnEditSelectChannel();
OnClearSelection(false);
return wParam;
case kcCutPattern:
PatternClipboard::Copy(sndFile, GetCurrentPattern());
OnEditSelectAll();
OnClearSelection(false);
return wParam;
case kcCopyPatternChannel:
PatternClipboard::Copy(sndFile, GetCurrentPattern(), GetCurrentChannel());
return wParam;
case kcCopyPattern:
PatternClipboard::Copy(sndFile, GetCurrentPattern());
return wParam;
case kcPastePatternChannel:
case kcPastePattern:
if(PatternClipboard::Paste(sndFile, GetCurrentPattern(), wParam == kcPastePatternChannel ? GetCurrentChannel() : CHANNELINDEX_INVALID))
{
SetModified();
InvalidatePattern();
GetDocument()->UpdateAllViews(this, PatternHint(GetCurrentPattern()).Data(), this);
}
return wParam;
case kcTogglePatternPlayRow:
TrackerSettings::Instance().m_dwPatternSetup ^= PATTERN_PLAYNAVIGATEROW;
CMainFrame::GetMainFrame()->SetHelpText((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_PLAYNAVIGATEROW)
? _T("Play whole row when navigatin was turned is now enabled.") : _T("Play whole row when navigatin was turned is now disabled."));
return wParam;
}
// Ignore note entry if it is on key hold and user is in key-jazz mode or edit step is 0 (so repeated entry would be useless)
const auto keyCombination = KeyCombination::FromLPARAM(lParam);
const bool enterNote = keyCombination.EventType() != kKeyEventRepeat || (IsEditingEnabled() && m_nSpacing != 0);
// Ranges:
if(wParam >= kcVPStartNotes && wParam <= kcVPEndNotes)
{
if(enterNote)
TempEnterNote(GetNoteWithBaseOctave(static_cast<int>(wParam - kcVPStartNotes)));
return wParam;
} else if(wParam >= kcVPStartChords && wParam <= kcVPEndChords)
{
if(enterNote)
TempEnterChord(GetNoteWithBaseOctave(static_cast<int>(wParam - kcVPStartChords)));
return wParam;
}
if(wParam >= kcVPStartNoteStops && wParam <= kcVPEndNoteStops)
{
TempStopNote(GetNoteWithBaseOctave(static_cast<int>(wParam - kcVPStartNoteStops)));
return wParam;
} else if(wParam >= kcVPStartChordStops && wParam <= kcVPEndChordStops)
{
TempStopChord(GetNoteWithBaseOctave(static_cast<int>(wParam - kcVPStartChordStops)));
return wParam;
}
if(wParam >= kcSetSpacing0 && wParam <= kcSetSpacing9)
{
SetSpacing(static_cast<int>(wParam) - kcSetSpacing0);
return wParam;
}
if(wParam >= kcSetIns0 && wParam <= kcSetIns9)
{
if(IsEditingEnabled_bmsg())
TempEnterIns(static_cast<int>(wParam) - kcSetIns0);
return wParam;
}
if(wParam >= kcSetOctave0 && wParam <= kcSetOctave9)
{
if(IsEditingEnabled_bmsg())
TempEnterOctave(static_cast<int>(wParam) - kcSetOctave0);
return wParam;
}
if(wParam >= kcSetOctaveStop0 && wParam <= kcSetOctaveStop9)
{
TempStopOctave(static_cast<int>(wParam) - kcSetOctaveStop0);
return wParam;
}
if(wParam >= kcSetVolumeStart && wParam <= kcSetVolumeEnd)
{
if(IsEditingEnabled_bmsg())
TempEnterVol(static_cast<int>(wParam) - kcSetVolumeStart);
return wParam;
}
if(wParam >= kcSetFXStart && wParam <= kcSetFXEnd)
{
if(IsEditingEnabled_bmsg())
TempEnterFX(static_cast<ModCommand::COMMAND>(wParam - kcSetFXStart + 1));
return wParam;
}
if(wParam >= kcSetFXParam0 && wParam <= kcSetFXParamF)
{
if(IsEditingEnabled_bmsg())
TempEnterFXparam(static_cast<int>(wParam) - kcSetFXParam0);
return wParam;
}
return kcNull;
}
// Move pattern cursor to left or right, respecting invisible columns.
void CViewPattern::MoveCursor(bool moveRight)
{
if(!moveRight)
{
// Move cursor one column to the left
if((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_WRAP) && m_Cursor.IsInFirstColumn())
{
// Wrap around to last channel
SetCurrentColumn(GetDocument()->GetNumChannels() - 1, m_nDetailLevel);
} else if(!m_Cursor.IsInFirstColumn())
{
m_Cursor.Move(0, 0, -1);
SetCurrentColumn(m_Cursor);
}
} else
{
// Move cursor one column to the right
const PatternCursor rightmost(0, GetDocument()->GetNumChannels() - 1, m_nDetailLevel);
if(m_Cursor.CompareColumn(rightmost) >= 0)
{
if((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_WRAP))
{
// Wrap around to first channel.
SetCurrentColumn(0);
} else
{
SetCurrentColumn(rightmost);
}
} else
{
do
{
m_Cursor.Move(0, 0, 1);
} while(m_Cursor.GetColumnType() > m_nDetailLevel);
SetCurrentColumn(m_Cursor);
}
}
}
static bool EnterPCNoteValue(int v, ModCommand &m, uint16 (ModCommand::*getMethod)() const, void (ModCommand::*setMethod)(uint16))
{
if(v < 0 || v > 9)
return false;
uint16 val = (m.*getMethod)();
// Move existing digits to left, drop out leftmost digit and push new digit to the least significant digit.
val = static_cast<uint16>((val % 100) * 10 + v);
LimitMax(val, static_cast<uint16>(ModCommand::maxColumnValue));
(m.*setMethod)(val);
return true;
}
// Enter volume effect / number in the pattern.
void CViewPattern::TempEnterVol(int v)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !IsEditingEnabled_bmsg())
return;
PrepareUndo(m_Cursor, m_Cursor, "Volume Entry");
ModCommand &target = GetCursorCommand();
ModCommand oldcmd = target; // This is the command we are about to overwrite
const bool isDigit = (v >= 0) && (v <= 9);
if(target.IsPcNote())
{
if(EnterPCNoteValue(v, target, &ModCommand::GetValueVolCol, &ModCommand::SetValueVolCol))
m_PCNoteEditMemory = target;
} else
{
ModCommand::VOLCMD volcmd = target.volcmd;
uint16 vol = target.vol;
if(isDigit)
{
vol = ((vol * 10) + v) % 100;
if(!volcmd)
volcmd = VOLCMD_VOLUME;
} else
{
switch(v + kcSetVolumeStart)
{
case kcSetVolumeVol: volcmd = VOLCMD_VOLUME; break;
case kcSetVolumePan: volcmd = VOLCMD_PANNING; break;
case kcSetVolumeVolSlideUp: volcmd = VOLCMD_VOLSLIDEUP; break;
case kcSetVolumeVolSlideDown: volcmd = VOLCMD_VOLSLIDEDOWN; break;
case kcSetVolumeFineVolUp: volcmd = VOLCMD_FINEVOLUP; break;
case kcSetVolumeFineVolDown: volcmd = VOLCMD_FINEVOLDOWN; break;
case kcSetVolumeVibratoSpd: volcmd = VOLCMD_VIBRATOSPEED; break;
case kcSetVolumeVibrato: volcmd = VOLCMD_VIBRATODEPTH; break;
case kcSetVolumeXMPanLeft: volcmd = VOLCMD_PANSLIDELEFT; break;
case kcSetVolumeXMPanRight: volcmd = VOLCMD_PANSLIDERIGHT; break;
case kcSetVolumePortamento: volcmd = VOLCMD_TONEPORTAMENTO; break;
case kcSetVolumeITPortaUp: volcmd = VOLCMD_PORTAUP; break;
case kcSetVolumeITPortaDown: volcmd = VOLCMD_PORTADOWN; break;
case kcSetVolumeITOffset: volcmd = VOLCMD_OFFSET; break;
}
if(target.volcmd == VOLCMD_NONE && volcmd == m_cmdOld.volcmd)
{
vol = m_cmdOld.vol;
}
}
uint16 max;
switch(volcmd)
{
case VOLCMD_VOLUME:
case VOLCMD_PANNING:
max = 64;
break;
default:
max = (pSndFile->GetType() == MOD_TYPE_XM) ? 0x0F : 9;
break;
}
if(vol > max)
vol %= 10;
if(pSndFile->GetModSpecifications().HasVolCommand(volcmd))
{
m_cmdOld.volcmd = target.volcmd = volcmd;
m_cmdOld.vol = target.vol = static_cast<ModCommand::VOL>(vol);
}
}
SetSelToCursor();
if(oldcmd != target)
{
SetModified(false);
InvalidateCell(m_Cursor);
UpdateIndicator();
}
// Cursor step for command letter
if(!target.IsPcNote() && !isDigit && m_nSpacing > 0 && !IsLiveRecord() && TrackerSettings::Instance().patternStepCommands)
{
if(m_Cursor.GetRow() + m_nSpacing < pSndFile->Patterns[m_nPattern].GetNumRows() || (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL))
{
SetCurrentRow(m_Cursor.GetRow() + m_nSpacing, (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL) != 0);
}
}
}
void CViewPattern::SetSpacing(int n)
{
if(static_cast<UINT>(n) != m_nSpacing)
{
m_nSpacing = static_cast<UINT>(n);
PostCtrlMessage(CTRLMSG_SETSPACING, m_nSpacing);
}
}
// Enter an effect letter in the pattern
void CViewPattern::TempEnterFX(ModCommand::COMMAND c, int v)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !IsEditingEnabled_bmsg())
{
return;
}
ModCommand &target = GetCursorCommand();
ModCommand oldcmd = target; // This is the command we are about to overwrite
PrepareUndo(m_Cursor, m_Cursor, "Effect Entry");
if(target.IsPcNote())
{
if(EnterPCNoteValue(c, target, &ModCommand::GetValueEffectCol, &ModCommand::SetValueEffectCol))
m_PCNoteEditMemory = target;
} else if(pSndFile->GetModSpecifications().HasCommand(c))
{
if(c != CMD_NONE)
{
if((c == m_cmdOld.command) && (!target.param) && (target.command == CMD_NONE))
{
target.param = m_cmdOld.param;
} else
{
m_cmdOld.param = 0;
}
m_cmdOld.command = c;
}
target.command = c;
if(v >= 0)
{
target.param = static_cast<ModCommand::PARAM>(v);
}
// Check for MOD/XM Speed/Tempo command
if((pSndFile->GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM))
&& (target.command == CMD_SPEED || target.command == CMD_TEMPO))
{
target.command = static_cast<ModCommand::COMMAND>((target.param <= pSndFile->GetModSpecifications().speedMax) ? CMD_SPEED : CMD_TEMPO);
}
}
SetSelToCursor();
if(oldcmd != target)
{
SetModified(false);
InvalidateCell(m_Cursor);
UpdateIndicator();
}
// Cursor step for command letter
if(!target.IsPcNote() && m_nSpacing > 0 && !IsLiveRecord() && TrackerSettings::Instance().patternStepCommands)
{
if(m_Cursor.GetRow() + m_nSpacing < pSndFile->Patterns[m_nPattern].GetNumRows() || (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL))
{
SetCurrentRow(m_Cursor.GetRow() + m_nSpacing, (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL) != 0);
}
}
}
// Enter an effect param in the pattenr
void CViewPattern::TempEnterFXparam(int v)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !IsEditingEnabled_bmsg())
{
return;
}
ModCommand &target = GetCursorCommand();
ModCommand oldcmd = target; // This is the command we are about to overwrite
PrepareUndo(m_Cursor, m_Cursor, "Parameter Entry");
if(target.IsPcNote())
{
if(EnterPCNoteValue(v, target, &ModCommand::GetValueEffectCol, &ModCommand::SetValueEffectCol))
m_PCNoteEditMemory = target;
} else
{
target.param = static_cast<ModCommand::PARAM>((target.param << 4) | v);
if(target.command == m_cmdOld.command)
{
m_cmdOld.param = target.param;
}
// Check for MOD/XM Speed/Tempo command
if((pSndFile->GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM))
&& (target.command == CMD_SPEED || target.command == CMD_TEMPO))
{
target.command = static_cast<ModCommand::COMMAND>((target.param <= pSndFile->GetModSpecifications().speedMax) ? CMD_SPEED : CMD_TEMPO);
}
}
SetSelToCursor();
if(target != oldcmd)
{
SetModified(false);
InvalidateCell(m_Cursor);
UpdateIndicator();
}
}
// Stop a note that has been entered
void CViewPattern::TempStopNote(ModCommand::NOTE note, const bool fromMidi, bool chordMode)
{
CModDoc *pModDoc = GetDocument();
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
if(pModDoc == nullptr || pMainFrm == nullptr || !ModCommand::IsNote(note))
{
return;
}
CSoundFile &sndFile = pModDoc->GetSoundFile();
if(!sndFile.Patterns.IsValidPat(m_nPattern))
{
return;
}
const CModSpecifications &specs = sndFile.GetModSpecifications();
Limit(note, specs.noteMin, specs.noteMax);
const bool liveRecord = IsLiveRecord();
const bool isSplit = IsNoteSplit(note);
UINT ins = 0;
chordMode = chordMode && (m_prevChordNote != NOTE_NONE);
auto &activeNoteMap = isSplit ? m_splitActiveNoteChannel : m_activeNoteChannel;
const CHANNELINDEX nChnCursor = GetCurrentChannel();
const CHANNELINDEX nChn = chordMode ? m_chordPatternChannels[0] : (activeNoteMap[note] < sndFile.GetNumChannels() ? activeNoteMap[note] : nChnCursor);
CHANNELINDEX noteChannels[MPTChord::notesPerChord] = {nChn};
ModCommand::NOTE notes[MPTChord::notesPerChord] = {note};
int numNotes = 1;
if(pModDoc)
{
if(isSplit)
{
ins = pModDoc->GetSplitKeyboardSettings().splitInstrument;
if(pModDoc->GetSplitKeyboardSettings().octaveLink)
{
int trNote = note + 12 * pModDoc->GetSplitKeyboardSettings().octaveModifier;
Limit(trNote, specs.noteMin, specs.noteMax);
note = static_cast<ModCommand::NOTE>(trNote);
}
}
if(!ins)
ins = GetCurrentInstrument();
if(!ins)
ins = m_fallbackInstrument;
if(chordMode)
{
m_Status.reset(psChordPlaying);
numNotes = ConstructChord(note, notes, m_prevChordBaseNote);
if(!numNotes)
{
return;
}
for(int i = 0; i < numNotes; i++)
{
pModDoc->NoteOff(notes[i], true, static_cast<INSTRUMENTINDEX>(ins), m_noteChannel[notes[i] - NOTE_MIN]);
m_noteChannel[notes[i] - NOTE_MIN] = CHANNELINDEX_INVALID;
m_baPlayingNote.reset(notes[i]);
noteChannels[i] = m_chordPatternChannels[i];
}
m_prevChordNote = NOTE_NONE;
} else
{
m_baPlayingNote.reset(note);
pModDoc->NoteOff(note, ((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_NOTEFADE) || sndFile.GetNumInstruments() == 0), static_cast<INSTRUMENTINDEX>(ins), m_noteChannel[note - NOTE_MIN]);
m_noteChannel[note - NOTE_MIN] = CHANNELINDEX_INVALID;
}
}
// Enter note off in pattern?
if(!ModCommand::IsNote(note))
return;
if(m_Cursor.GetColumnType() > PatternCursor::instrColumn && (chordMode || !fromMidi))
return;
if(!pModDoc || !pMainFrm || !(IsEditingEnabled()))
return;
activeNoteMap[note] = NOTE_CHANNEL_MAP_INVALID; //unlock channel
if(!((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_KBDNOTEOFF) || fromMidi))
{
// We don't want to write the note-off into the pattern if this feature is disabled and we're not recording from MIDI.
return;
}
// -- write sdx if playing live
const bool usePlaybackPosition = (!chordMode) && (liveRecord && (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_AUTODELAY));
//Work out where to put the note off
PatternEditPos editPos = GetEditPos(sndFile, usePlaybackPosition);
const bool doQuantize = (liveRecord || (fromMidi && (TrackerSettings::Instance().m_dwMidiSetup & MIDISETUP_PLAYPATTERNONMIDIIN))) && TrackerSettings::Instance().recordQuantizeRows != 0;
if(doQuantize)
{
QuantizeRow(editPos.pattern, editPos.row);
}
ModCommand *pTarget = sndFile.Patterns[editPos.pattern].GetpModCommand(editPos.row, nChn);
// Don't overwrite:
if(pTarget->note != NOTE_NONE || pTarget->instr || pTarget->volcmd != VOLCMD_NONE)
{
// If there's a note in the current location and the song is playing and following,
// the user probably just tapped the key - let's try the next row down.
editPos.row++;
if(pTarget->note == note && liveRecord && sndFile.Patterns[editPos.pattern].IsValidRow(editPos.row))
{
pTarget = sndFile.Patterns[editPos.pattern].GetpModCommand(editPos.row, nChn);
if(pTarget->note != NOTE_NONE || (!chordMode && (pTarget->instr || pTarget->volcmd)))
return;
} else
{
return;
}
}
bool modified = false;
for(int i = 0; i < numNotes; i++)
{
if(m_previousNote[noteChannels[i]] != notes[i])
{
// This might be a note-off from a past note, but since we already hit a new note on this channel, we ignore it.
continue;
}
if(!modified)
{
pModDoc->GetPatternUndo().PrepareUndo(editPos.pattern, nChn, editPos.row, noteChannels[numNotes - 1] - nChn + 1, 1, "Note Stop Entry");
modified = true;
}
pTarget = sndFile.Patterns[editPos.pattern].GetpModCommand(editPos.row, noteChannels[i]);
// -- write sdx if playing live
if(usePlaybackPosition && m_nPlayTick && pTarget->command == CMD_NONE && !doQuantize)
{
pTarget->command = CMD_S3MCMDEX;
if(!specs.HasCommand(CMD_S3MCMDEX))
pTarget->command = CMD_MODCMDEX;
pTarget->param = static_cast<ModCommand::PARAM>(0xD0 | std::min(uint8(0xF), mpt::saturate_cast<uint8>(m_nPlayTick)));
}
//Enter note off
if(sndFile.GetModSpecifications().hasNoteOff && (sndFile.GetNumInstruments() > 0 || !sndFile.GetModSpecifications().hasNoteCut))
{
// ===
// Not used in sample (if module format supports ^^^ instead)
pTarget->note = NOTE_KEYOFF;
} else if(sndFile.GetModSpecifications().hasNoteCut)
{
// ^^^
pTarget->note = NOTE_NOTECUT;
} else
{
// we don't have anything to cut (MOD format) - use volume or ECx
if(usePlaybackPosition && m_nPlayTick && !doQuantize) // ECx
{
pTarget->command = CMD_S3MCMDEX;
if(!specs.HasCommand(CMD_S3MCMDEX))
pTarget->command = CMD_MODCMDEX;
pTarget->param = static_cast<ModCommand::PARAM>(0xC0 | std::min(uint8(0xF), mpt::saturate_cast<uint8>(m_nPlayTick)));
} else // C00
{
pTarget->note = NOTE_NONE;
pTarget->command = CMD_VOLUME;
pTarget->param = 0;
}
}
pTarget->instr = 0; // Instrument numbers next to note-offs can do all kinds of weird things in XM files, and they are pointless anyway.
pTarget->volcmd = VOLCMD_NONE;
pTarget->vol = 0;
}
if(!modified)
return;
SetModified(false);
if(editPos.pattern == m_nPattern)
{
InvalidateRow(editPos.row);
} else
{
InvalidatePattern();
}
// Update only if not recording live.
if(!liveRecord)
{
UpdateIndicator();
}
return;
}
// Enter an octave number in the pattern
void CViewPattern::TempEnterOctave(int val)
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr)
{
return;
}
const ModCommand &target = GetCursorCommand();
if(target.IsNote())
{
int groupSize = GetDocument()->GetInstrumentGroupSize(target.instr);
// The following might look a bit convoluted... This is mostly because the "middle-C" in
// custom tunings always has octave 5, no matter how many octaves the tuning actually has.
int note = mpt::wrapping_modulo(target.note - NOTE_MIDDLEC, groupSize) + (val - 5) * groupSize + NOTE_MIDDLEC;
Limit(note, NOTE_MIN, NOTE_MAX);
TempEnterNote(static_cast<ModCommand::NOTE>(note));
// Memorize note for key-up
ASSERT(size_t(val) < m_octaveKeyMemory.size());
m_octaveKeyMemory[val] = target.note;
}
}
// Stop note that has been triggered by entering an octave in the pattern.
void CViewPattern::TempStopOctave(int val)
{
ASSERT(size_t(val) < m_octaveKeyMemory.size());
if(m_octaveKeyMemory[val] != NOTE_NONE)
{
TempStopNote(m_octaveKeyMemory[val]);
m_octaveKeyMemory[val] = NOTE_NONE;
}
}
// Enter an instrument number in the pattern
void CViewPattern::TempEnterIns(int val)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !IsEditingEnabled_bmsg())
{
return;
}
PrepareUndo(m_Cursor, m_Cursor, "Instrument Entry");
ModCommand &target = GetCursorCommand();
ModCommand oldcmd = target; // This is the command we are about to overwrite
UINT instr = target.instr, nTotalMax, nTempMax;
if(target.IsPcNote()) // this is a plugin index
{
nTotalMax = MAX_MIXPLUGINS + 1;
nTempMax = MAX_MIXPLUGINS + 1;
} else if(pSndFile->GetNumInstruments() > 0) // this is an instrument index
{
nTotalMax = MAX_INSTRUMENTS;
nTempMax = pSndFile->GetNumInstruments();
} else
{
nTotalMax = MAX_SAMPLES;
nTempMax = pSndFile->GetNumSamples();
}
instr = ((instr * 10) + val) % 1000;
if(instr >= nTotalMax)
instr = instr % 100;
if(nTempMax < 100) // if we're using samples & have less than 100 samples
instr = instr % 100; // or if we're using instruments and have less than 100 instruments
// --> ensure the entered instrument value is less than 100.
target.instr = static_cast<ModCommand::INSTR>(instr);
SetSelToCursor();
if(target != oldcmd)
{
SetModified(false);
InvalidateCell(m_Cursor);
UpdateIndicator();
}
if(target.IsPcNote())
{
m_PCNoteEditMemory = target;
}
}
// Enter a note in the pattern
void CViewPattern::TempEnterNote(ModCommand::NOTE note, int vol, bool fromMidi)
{
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
CModDoc *pModDoc = GetDocument();
if(pMainFrm == nullptr || pModDoc == nullptr)
{
return;
}
CSoundFile &sndFile = pModDoc->GetSoundFile();
if(!sndFile.Patterns.IsValidPat(m_nPattern))
{
return;
}
if(note < NOTE_MIN_SPECIAL)
{
Limit(note, sndFile.GetModSpecifications().noteMin, sndFile.GetModSpecifications().noteMax);
}
// Special case: Convert note off commands to C00 for MOD files
if((sndFile.GetType() == MOD_TYPE_MOD) && (note == NOTE_NOTECUT || note == NOTE_FADE || note == NOTE_KEYOFF))
{
TempEnterFX(CMD_VOLUME, 0);
return;
}
// Check whether the module format supports the note.
if(sndFile.GetModSpecifications().HasNote(note) == false)
{
return;
}
const bool liveRecord = IsLiveRecord();
const bool usePlaybackPosition = (liveRecord && (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_AUTODELAY) && !sndFile.m_SongFlags[SONG_STEP]);
const bool isSpecial = note >= NOTE_MIN_SPECIAL;
const bool isSplit = IsNoteSplit(note);
PatternEditPos editPos = GetEditPos(sndFile, usePlaybackPosition);
const bool recordEnabled = IsEditingEnabled();
CHANNELINDEX nChn = GetCurrentChannel();
auto recordGroup = pModDoc->GetChannelRecordGroup(nChn);
if(!isSpecial && pModDoc->GetSplitKeyboardSettings().IsSplitActive()
&& ((recordGroup == RecordGroup::Group1 && isSplit) || (recordGroup == RecordGroup::Group2 && !isSplit)))
{
// Record group 1 should be used for normal notes, record group 2 for split notes.
// If there are any channels assigned to the "other" record group, we switch to another channel.
auto otherGroup = (recordGroup == RecordGroup::Group1) ? RecordGroup::Group2 : RecordGroup::Group1;
const CHANNELINDEX newChannel = FindGroupRecordChannel(otherGroup, true);
if(newChannel != CHANNELINDEX_INVALID)
{
// Found a free channel, switch to other record group.
nChn = newChannel;
recordGroup = otherGroup;
}
}
// -- Chord autodetection: step back if we just entered a note
if(recordEnabled && recordGroup != RecordGroup::NoGroup && !liveRecord && !ModCommand::IsPcNote(note) && m_nSpacing > 0)
{
const auto &order = Order();
if((timeGetTime() - m_autoChordStartTime) < TrackerSettings::Instance().gnAutoChordWaitTime
&& order.IsValidPat(m_autoChordStartOrder)
&& sndFile.Patterns[order[m_autoChordStartOrder]].IsValidRow(m_autoChordStartRow))
{
const auto pattern = order[m_autoChordStartOrder];
if(pattern != editPos.pattern)
{
SetCurrentOrder(m_autoChordStartOrder);
SetCurrentPattern(pattern, m_autoChordStartRow);
}
editPos.pattern = pattern;
editPos.row = m_autoChordStartRow;
} else
{
m_autoChordStartRow = ROWINDEX_INVALID;
m_autoChordStartOrder = ORDERINDEX_INVALID;
}
m_autoChordStartTime = timeGetTime();
if(m_autoChordStartOrder == ORDERINDEX_INVALID || m_autoChordStartRow == ROWINDEX_INVALID)
{
m_autoChordStartOrder = editPos.order;
m_autoChordStartRow = editPos.row;
}
}
// Quantize
const bool doQuantize = (liveRecord || (fromMidi && (TrackerSettings::Instance().m_dwMidiSetup & MIDISETUP_PLAYPATTERNONMIDIIN))) && TrackerSettings::Instance().recordQuantizeRows != 0;
if(doQuantize)
{
QuantizeRow(editPos.pattern, editPos.row);
// "Grace notes" are stuffed into the next row, if possible
if(sndFile.Patterns[editPos.pattern].GetpModCommand(editPos.row, nChn)->IsNote() && editPos.row < sndFile.Patterns[editPos.pattern].GetNumRows() - 1)
{
editPos.row++;
}
}
// -- Work out where to put the new note
ModCommand *pTarget = sndFile.Patterns[editPos.pattern].GetpModCommand(editPos.row, nChn);
ModCommand newcmd = *pTarget;
// Param control 'note'
if(ModCommand::IsPcNote(note))
{
if(!pTarget->IsPcNote())
{
// We're overwriting a normal cell with a PC note.
newcmd = m_PCNoteEditMemory;
if((pTarget->command == CMD_MIDI || pTarget->command == CMD_SMOOTHMIDI) && pTarget->param < 128)
{
newcmd.SetValueEffectCol(static_cast<decltype(newcmd.GetValueEffectCol())>(Util::muldivr(pTarget->param, ModCommand::maxColumnValue, 127)));
if(!newcmd.instr)
newcmd.instr = sndFile.ChnSettings[nChn].nMixPlugin;
auto activeMacro = sndFile.m_PlayState.Chn[nChn].nActiveMacro;
if(!newcmd.GetValueVolCol() && sndFile.m_MidiCfg.GetParameteredMacroType(activeMacro) == kSFxPlugParam)
{
PlugParamIndex plugParam = sndFile.m_MidiCfg.MacroToPlugParam(sndFile.m_PlayState.Chn[nChn].nActiveMacro);
if(plugParam < ModCommand::maxColumnValue)
newcmd.SetValueVolCol(static_cast<decltype(newcmd.GetValueVolCol())>(plugParam));
}
}
} else if(recordEnabled)
{
// Pick up current entry to update PC note edit memory.
m_PCNoteEditMemory = newcmd;
}
newcmd.note = note;
} else
{
// Are we overwriting a PC note here?
if(pTarget->IsPcNote())
{
newcmd.Clear();
}
// -- write note and instrument data.
HandleSplit(newcmd, note);
// Nice idea actually: Use lower section of the keyboard to play chords (but it won't work 100% correctly this way...)
/*if(isSplit)
{
TempEnterChord(note);
return;
}*/
// -- write vol data
int volWrite = -1;
if(vol >= 0 && vol <= 64 && !(isSplit && pModDoc->GetSplitKeyboardSettings().splitVolume)) //write valid volume, as long as there's no split volume override.
{
volWrite = vol;
} else if(isSplit && pModDoc->GetSplitKeyboardSettings().splitVolume) //cater for split volume override.
{
if(pModDoc->GetSplitKeyboardSettings().splitVolume > 0 && pModDoc->GetSplitKeyboardSettings().splitVolume <= 64)
{
volWrite = pModDoc->GetSplitKeyboardSettings().splitVolume;
}
}
if(volWrite != -1 && !isSpecial)
{
if(sndFile.GetModSpecifications().HasVolCommand(VOLCMD_VOLUME))
{
newcmd.volcmd = VOLCMD_VOLUME;
newcmd.vol = (ModCommand::VOL)volWrite;
} else
{
newcmd.command = CMD_VOLUME;
newcmd.param = (ModCommand::PARAM)volWrite;
}
}
// -- write sdx if playing live
if(usePlaybackPosition && m_nPlayTick && !doQuantize) // avoid SD0 which will be mis-interpreted
{
if(newcmd.command == CMD_NONE) //make sure we don't overwrite any existing commands.
{
newcmd.command = CMD_S3MCMDEX;
if(!sndFile.GetModSpecifications().HasCommand(CMD_S3MCMDEX))
newcmd.command = CMD_MODCMDEX;
uint8 maxSpeed = 0x0F;
if(m_nTicksOnRow > 0)
maxSpeed = std::min(uint8(0x0F), mpt::saturate_cast<uint8>(m_nTicksOnRow - 1));
newcmd.param = static_cast<ModCommand::PARAM>(0xD0 | std::min(maxSpeed, mpt::saturate_cast<uint8>(m_nPlayTick)));
}
}
// Note cut/off/fade: erase instrument number
if(newcmd.note >= NOTE_MIN_SPECIAL)
newcmd.instr = 0;
}
// -- if recording, create undo point and write out modified command.
const bool modified = (recordEnabled && *pTarget != newcmd);
if(modified)
{
pModDoc->GetPatternUndo().PrepareUndo(editPos.pattern, nChn, editPos.row, 1, 1, "Note Entry");
*pTarget = newcmd;
}
// -- play note
if(((TrackerSettings::Instance().m_dwPatternSetup & (PATTERN_PLAYNEWNOTE | PATTERN_PLAYEDITROW)) || !recordEnabled) && !newcmd.IsPcNote())
{
const bool playWholeRow = ((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_PLAYEDITROW) && !liveRecord);
if(playWholeRow)
{
// play the whole row in "step mode"
PatternStep(editPos.row);
if(recordEnabled && newcmd.IsNote())
m_noteChannel[newcmd.note - NOTE_MIN] = nChn;
}
if(!playWholeRow || !recordEnabled)
{
// NOTE: This code is *also* used for the PATTERN_PLAYEDITROW edit mode because of some unforseeable race conditions when modifying pattern data.
// We have to use this code when editing is disabled or else we will get some stupid hazards, because we would first have to write the new note
// data to the pattern and then remove it again - but often, it is actually removed before the row is parsed by the soundlib.
// just play the newly inserted note using the already specified instrument...
ModCommand::INSTR playIns = newcmd.instr;
if(!playIns && ModCommand::IsNoteOrEmpty(note))
{
// ...or one that can be found on a previous row of this pattern.
ModCommand *search = pTarget;
ROWINDEX srow = editPos.row;
while(srow-- > 0)
{
search -= sndFile.GetNumChannels();
if(search->instr && !search->IsPcNote())
{
playIns = search->instr;
m_fallbackInstrument = playIns; //used to figure out which instrument to stop on key release.
break;
}
}
}
PlayNote(newcmd.note, playIns, 4 * vol, nChn);
}
}
if(newcmd.IsNote())
{
m_previousNote[nChn] = note;
}
// -- if recording, handle post note entry behaviour (move cursor etc..)
if(recordEnabled)
{
PatternCursor sel(editPos.row, nChn, m_Cursor.GetColumnType());
if(!liveRecord)
{
// Update only when not recording live.
SetCurSel(sel);
}
if(modified) // Has it really changed?
{
SetModified(false);
if(editPos.pattern == m_nPattern)
InvalidateCell(sel);
else
InvalidatePattern();
if(!liveRecord)
{
// Update only when not recording live.
UpdateIndicator();
}
}
// Set new cursor position (edit step aka row spacing)
if(!liveRecord)
{
if(m_nSpacing > 0)
{
if(editPos.row + m_nSpacing < sndFile.Patterns[editPos.pattern].GetNumRows() || (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL))
{
SetCurrentRow(editPos.row + m_nSpacing, (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL) != 0);
}
}
SetSelToCursor();
}
if(newcmd.IsPcNote())
{
// Nothing to do here anymore.
return;
}
auto &activeNoteMap = isSplit ? m_splitActiveNoteChannel : m_activeNoteChannel;
if(newcmd.note <= NOTE_MAX)
activeNoteMap[newcmd.note] = static_cast<decltype(m_activeNoteChannel)::value_type>(nChn);
if(recordGroup != RecordGroup::NoGroup)
{
// Move to next channel in record group
nChn = FindGroupRecordChannel(recordGroup, false, nChn + 1);
if(nChn != CHANNELINDEX_INVALID)
{
SetCurrentColumn(nChn);
}
}
}
}
void CViewPattern::PlayNote(ModCommand::NOTE note, ModCommand::INSTR instr, int volume, CHANNELINDEX channel)
{
CModDoc *modDoc = GetDocument();
modDoc->PlayNote(PlayNoteParam(note).Instrument(instr).Volume(volume).Channel(channel).CheckNNA(m_baPlayingNote), &m_noteChannel);
}
void CViewPattern::PreviewNote(ROWINDEX row, CHANNELINDEX channel)
{
const ModCommand &m = *GetSoundFile()->Patterns[m_nPattern].GetpModCommand(row, channel);
if(m.IsNote() && m.instr)
{
int vol = -1;
if(m.command == CMD_VOLUME)
vol = m.param * 4u;
else if(m.volcmd == VOLCMD_VOLUME)
vol = m.vol * 4u;
// Note-off any previews from this channel first
ModCommand::NOTE note = NOTE_MIN;
const auto &channels = GetSoundFile()->m_PlayState.Chn;
for(auto &chn : m_noteChannel)
{
if(chn != CHANNELINDEX_INVALID && channels[chn].isPreviewNote && channels[chn].nMasterChn == channel + 1)
{
GetDocument()->NoteOff(note, false, m.instr, chn);
}
note++;
}
PlayNote(m.note, m.instr, vol, channel);
}
}
// Construct a chord from the chord presets. Returns number of notes in chord.
int CViewPattern::ConstructChord(int note, ModCommand::NOTE (&outNotes)[MPTChord::notesPerChord], ModCommand::NOTE baseNote)
{
const MPTChords &chords = TrackerSettings::GetChords();
UINT chordNum = note - GetBaseNote();
if(chordNum >= chords.size())
{
return 0;
}
const MPTChord &chord = chords[chordNum];
const bool relativeMode = (chord.key == MPTChord::relativeMode); // Notes are relative to a previously entered note in the pattern
ModCommand::NOTE key;
if(relativeMode)
{
// Relative mode: Use pattern note as base note.
// If there is no valid note in the pattern: Use shortcut note as relative base note
key = ModCommand::IsNote(baseNote) ? baseNote : static_cast<ModCommand::NOTE>(note);
} else
{
// Default mode: Use base key
key = GetNoteWithBaseOctave(chord.key);
}
if(!ModCommand::IsNote(key))
{
return 0;
}
int numNotes = 0;
const CModSpecifications &specs = GetSoundFile()->GetModSpecifications();
if(specs.HasNote(key))
{
outNotes[numNotes++] = key;
}
int32 baseKey = key - NOTE_MIN;
if(!relativeMode)
{
// Only use octave information from the base key
baseKey = (baseKey / 12) * 12;
}
for(auto cnote : chord.notes)
{
if(cnote != MPTChord::noNote)
{
int32 chordNote = baseKey + cnote + NOTE_MIN;
if(chordNote >= NOTE_MIN && chordNote <= NOTE_MAX && specs.HasNote(static_cast<ModCommand::NOTE>(chordNote)))
{
outNotes[numNotes++] = static_cast<ModCommand::NOTE>(chordNote);
}
}
}
return numNotes;
}
// Enter a chord in the pattern
void CViewPattern::TempEnterChord(ModCommand::NOTE note)
{
CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
CModDoc *pModDoc = GetDocument();
if(pMainFrm == nullptr || pModDoc == nullptr)
{
return;
}
CSoundFile &sndFile = pModDoc->GetSoundFile();
if(!sndFile.Patterns.IsValidPat(m_nPattern))
{
return;
}
const CHANNELINDEX chn = GetCurrentChannel();
const PatternRow rowBase = sndFile.Patterns[m_nPattern].GetRow(GetCurrentRow());
ModCommand::NOTE chordNotes[MPTChord::notesPerChord], baseNote = rowBase[chn].note;
if(!ModCommand::IsNote(baseNote))
{
baseNote = m_prevChordBaseNote;
}
int numNotes = ConstructChord(note, chordNotes, baseNote);
if(!numNotes)
{
return;
}
// Save old row contents
std::vector<ModCommand> newRow(rowBase, rowBase + sndFile.GetNumChannels());
const bool liveRecord = IsLiveRecord();
const bool recordEnabled = IsEditingEnabled();
bool modified = false;
// -- establish note data
HandleSplit(newRow[chn], note);
const auto recordGroup = pModDoc->GetChannelRecordGroup(chn);
CHANNELINDEX curChn = chn;
for(int i = 0; i < numNotes; i++)
{
// Find appropriate channel
while(curChn < sndFile.GetNumChannels() && pModDoc->GetChannelRecordGroup(curChn) != recordGroup)
{
curChn++;
}
if(curChn >= sndFile.GetNumChannels())
{
numNotes = i;
break;
}
m_chordPatternChannels[i] = curChn;
ModCommand &m = newRow[curChn];
m_previousNote[curChn] = m.note = chordNotes[i];
if(newRow[chn].instr)
{
m.instr = newRow[chn].instr;
}
if(rowBase[chn] != m)
{
modified = true;
}
curChn++;
}
m_Status.set(psChordPlaying);
// -- write notedata
if(recordEnabled)
{
SetSelToCursor();
if(modified)
{
// Simply backup the whole row.
pModDoc->GetPatternUndo().PrepareUndo(m_nPattern, chn, GetCurrentRow(), sndFile.GetNumChannels(), 1, "Chord Entry");
for(CHANNELINDEX n = 0; n < sndFile.GetNumChannels(); n++)
{
rowBase[n] = newRow[n];
}
SetModified(false);
InvalidateRow();
UpdateIndicator();
}
}
// -- play note
if((TrackerSettings::Instance().m_dwPatternSetup & (PATTERN_PLAYNEWNOTE | PATTERN_PLAYEDITROW)) || !recordEnabled)
{
if(m_prevChordNote != NOTE_NONE)
{
TempStopChord(m_prevChordNote);
}
const bool playWholeRow = ((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_PLAYEDITROW) && !liveRecord);
if(playWholeRow)
{
// play the whole row in "step mode"
PatternStep(GetCurrentRow());
if(recordEnabled)
{
for(int i = 0; i < numNotes; i++)
{
m_noteChannel[chordNotes[i] - NOTE_MIN] = m_chordPatternChannels[i];
}
}
}
if(!playWholeRow || !recordEnabled)
{
// NOTE: This code is *also* used for the PATTERN_PLAYEDITROW edit mode because of some unforseeable race conditions when modifying pattern data.
// We have to use this code when editing is disabled or else we will get some stupid hazards, because we would first have to write the new note
// data to the pattern and then remove it again - but often, it is actually removed before the row is parsed by the soundlib.
// just play the newly inserted notes...
const ModCommand &firstNote = rowBase[chn];
ModCommand::INSTR playIns = 0;
if(firstNote.instr)
{
// ...using the already specified instrument
playIns = firstNote.instr;
} else if(!firstNote.instr)
{
// ...or one that can be found on a previous row of this pattern.
const ModCommand *search = &firstNote;
ROWINDEX srow = GetCurrentRow();
while(srow-- > 0)
{
search -= sndFile.GetNumChannels();
if(search->instr)
{
playIns = search->instr;
m_fallbackInstrument = playIns; //used to figure out which instrument to stop on key release.
break;
}
}
}
for(int i = 0; i < numNotes; i++)
{
pModDoc->PlayNote(PlayNoteParam(chordNotes[i]).Instrument(playIns).Channel(chn).CheckNNA(m_baPlayingNote), &m_noteChannel);
}
}
} // end play note
m_prevChordNote = note;
m_prevChordBaseNote = baseNote;
// Set new cursor position (edit step aka row spacing) - only when not recording live
if(recordEnabled && !liveRecord)
{
if(m_nSpacing > 0)
{
// Shift from entering chord may have triggered this flag, which will prevent us from wrapping to the next pattern.
m_Status.reset(psKeyboardDragSelect);
SetCurrentRow(GetCurrentRow() + m_nSpacing, (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_CONTSCROLL) != 0);
}
SetSelToCursor();
}
}
// Translate incoming MIDI aftertouch messages to pattern commands
void CViewPattern::EnterAftertouch(ModCommand::NOTE note, int atValue)
{
if(TrackerSettings::Instance().aftertouchBehaviour == atDoNotRecord || !IsEditingEnabled())
return;
const CHANNELINDEX numChannels = GetSoundFile()->GetNumChannels();
std::set<CHANNELINDEX> channels;
if(ModCommand::IsNote(note))
{
// For polyphonic aftertouch, map the aftertouch note to the correct pattern channel.
const auto &activeNoteMap = IsNoteSplit(note) ? m_splitActiveNoteChannel : m_activeNoteChannel;
if(activeNoteMap[note] < numChannels)
{
channels.insert(activeNoteMap[note]);
} else
{
// Couldn't find the channel that belongs to this note... Don't bother writing aftertouch messages.
// This is actually necessary, because it is possible that the last aftertouch message for a note
// is received after the key-off event, in which case OpenMPT won't know anymore on which channel
// that particular note was, so it will just put the message on some other channel. We don't want that!
return;
}
} else
{
for(const auto &noteMap : { m_activeNoteChannel, m_splitActiveNoteChannel })
{
for(const auto chn : noteMap)
{
if(chn < numChannels)
channels.insert(chn);
}
}
if(channels.empty())
channels.insert(m_Cursor.GetChannel());
}
Limit(atValue, 0, 127);
const PatternCursor endOfRow{ m_Cursor.GetRow(), static_cast<CHANNELINDEX>(numChannels - 1u), PatternCursor::lastColumn };
const auto &specs = GetSoundFile()->GetModSpecifications();
bool first = true, modified = false;
for(const auto chn : channels)
{
const PatternCursor cursor{ m_Cursor.GetRow(), chn };
ModCommand &target = GetModCommand(cursor);
ModCommand newCommand = target;
if(target.IsPcNote())
continue;
switch(TrackerSettings::Instance().aftertouchBehaviour)
{
case atRecordAsVolume:
// Record aftertouch messages as volume commands
if(specs.HasVolCommand(VOLCMD_VOLUME))
{
if(newCommand.volcmd == VOLCMD_NONE || newCommand.volcmd == VOLCMD_VOLUME)
{
newCommand.volcmd = VOLCMD_VOLUME;
newCommand.vol = static_cast<ModCommand::VOL>((atValue * 64 + 64) / 127);
}
} else if(specs.HasCommand(CMD_VOLUME))
{
if(newCommand.command == CMD_NONE || newCommand.command == CMD_VOLUME)
{
newCommand.command = CMD_VOLUME;
newCommand.param = static_cast<ModCommand::PARAM>((atValue * 64 + 64) / 127);
}
}
break;
case atRecordAsMacro:
// Record aftertouch messages as MIDI Macros
if(newCommand.command == CMD_NONE || newCommand.command == CMD_SMOOTHMIDI || newCommand.command == CMD_MIDI)
{
auto cmd =
specs.HasCommand(CMD_SMOOTHMIDI) ? CMD_SMOOTHMIDI :
specs.HasCommand(CMD_MIDI) ? CMD_MIDI :
CMD_NONE;
if(cmd != CMD_NONE)
{
newCommand.command = static_cast<ModCommand::COMMAND>(cmd);
newCommand.param = static_cast<ModCommand::PARAM>(atValue);
}
}
break;
}
if(target != newCommand)
{
if(first)
PrepareUndo(cursor, endOfRow, "Aftertouch Entry");
first = false;
modified = true;
target = newCommand;
InvalidateCell(cursor);
}
}
if(modified)
{
SetModified(false);
UpdateIndicator();
}
}
// Apply quantization factor to given row.
void CViewPattern::QuantizeRow(PATTERNINDEX &pat, ROWINDEX &row) const
{
const CSoundFile *sndFile = GetSoundFile();
if(sndFile == nullptr || TrackerSettings::Instance().recordQuantizeRows == 0)
{
return;
}
const ROWINDEX currentTick = m_nTicksOnRow * row + m_nPlayTick;
const ROWINDEX ticksPerNote = TrackerSettings::Instance().recordQuantizeRows * m_nTicksOnRow;
// Previous quantization step
const ROWINDEX quantLow = (currentTick / ticksPerNote) * ticksPerNote;
// Next quantization step
const ROWINDEX quantHigh = (1 + (currentTick / ticksPerNote)) * ticksPerNote;
if(currentTick - quantLow < quantHigh - currentTick)
{
row = quantLow / m_nTicksOnRow;
} else
{
row = quantHigh / m_nTicksOnRow;
}
if(!sndFile->Patterns[pat].IsValidRow(row))
{
// Quantization exceeds current pattern, try stuffing note into next pattern instead.
PATTERNINDEX nextPat = sndFile->m_SongFlags[SONG_PATTERNLOOP] ? m_nPattern : GetNextPattern();
if(nextPat != PATTERNINDEX_INVALID)
{
pat = nextPat;
row = 0;
} else
{
row = sndFile->Patterns[pat].GetNumRows() - 1;
}
}
}
// Get previous pattern in order list
PATTERNINDEX CViewPattern::GetPrevPattern() const
{
const CSoundFile *sndFile = GetSoundFile();
if(sndFile != nullptr)
{
const auto &order = Order();
const ORDERINDEX curOrder = GetCurrentOrder();
if(curOrder > 0 && m_nPattern == order[curOrder])
{
const ORDERINDEX nextOrder = order.GetPreviousOrderIgnoringSkips(curOrder);
const PATTERNINDEX nextPat = order[nextOrder];
if(sndFile->Patterns.IsValidPat(nextPat) && sndFile->Patterns[nextPat].GetNumRows())
{
return nextPat;
}
}
}
return PATTERNINDEX_INVALID;
}
// Get follow-up pattern in order list
PATTERNINDEX CViewPattern::GetNextPattern() const
{
const CSoundFile *sndFile = GetSoundFile();
if(sndFile != nullptr)
{
const auto &order = Order();
const ORDERINDEX curOrder = GetCurrentOrder();
if(curOrder + 1 < order.GetLength() && m_nPattern == order[curOrder])
{
const ORDERINDEX nextOrder = order.GetNextOrderIgnoringSkips(curOrder);
const PATTERNINDEX nextPat = order[nextOrder];
if(sndFile->Patterns.IsValidPat(nextPat) && sndFile->Patterns[nextPat].GetNumRows())
{
return nextPat;
}
}
}
return PATTERNINDEX_INVALID;
}
void CViewPattern::OnSetQuantize()
{
CInputDlg dlg(this, _T("Quantize amount in rows for live recording (0 to disable):"), 0, MAX_PATTERN_ROWS, TrackerSettings::Instance().recordQuantizeRows);
if(dlg.DoModal())
{
TrackerSettings::Instance().recordQuantizeRows = static_cast<ROWINDEX>(dlg.resultAsInt);
}
}
void CViewPattern::OnLockPatternRows()
{
CSoundFile &sndFile = *GetSoundFile();
if(m_Selection.GetUpperLeft() != m_Selection.GetLowerRight())
{
sndFile.m_lockRowStart = m_Selection.GetStartRow();
sndFile.m_lockRowEnd = m_Selection.GetEndRow();
} else
{
sndFile.m_lockRowStart = sndFile.m_lockRowEnd = ROWINDEX_INVALID;
}
InvalidatePattern(true, true);
}
// Find a free channel for a record group, starting search from a given channel.
// If forceFreeChannel is true and all channels in the specified record group are active, some channel is picked from the specified record group.
CHANNELINDEX CViewPattern::FindGroupRecordChannel(RecordGroup recordGroup, bool forceFreeChannel, CHANNELINDEX startChannel) const
{
const CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr)
return CHANNELINDEX_INVALID;
CHANNELINDEX chn = startChannel;
CHANNELINDEX foundChannel = CHANNELINDEX_INVALID;
for(CHANNELINDEX i = 1; i < pModDoc->GetNumChannels(); i++, chn++)
{
if(chn >= pModDoc->GetNumChannels())
chn = 0; // loop around
if(pModDoc->GetChannelRecordGroup(chn) == recordGroup)
{
// Check if any notes are playing on this channel
bool channelLocked = false;
for(size_t k = 0; k < m_activeNoteChannel.size(); k++)
{
if(m_activeNoteChannel[k] == chn || m_splitActiveNoteChannel[k] == chn)
{
channelLocked = true;
break;
}
}
if(!channelLocked)
{
// Channel belongs to correct record group and no note is currently playing.
return chn;
}
if(forceFreeChannel)
{
// If all channels are active, we might still pick a random channel from the specified group.
foundChannel = chn;
}
}
}
return foundChannel;
}
void CViewPattern::OnClearField(const RowMask &mask, bool step, bool ITStyle)
{
CSoundFile *sndFile = GetSoundFile();
if(sndFile == nullptr || !IsEditingEnabled_bmsg())
return;
// If we have a selection, we want to do something different
if(m_Selection.GetUpperLeft() != m_Selection.GetLowerRight())
{
OnClearSelection(ITStyle);
return;
}
PrepareUndo(m_Cursor, m_Cursor, "Clear Field");
ModCommand &target = GetCursorCommand();
ModCommand oldcmd = target;
if(mask.note)
{
// Clear note
if(target.IsPcNote())
{
// Need to clear entire field if this is a PC Event.
target.Clear();
} else
{
target.note = NOTE_NONE;
if(ITStyle)
{
target.instr = 0;
}
}
}
if(mask.instrument)
{
// Clear instrument
target.instr = 0;
}
if(mask.volume)
{
// Clear volume effect
target.volcmd = VOLCMD_NONE;
target.vol = 0;
}
if(mask.command)
{
// Clear effect command
target.command = CMD_NONE;
}
if(mask.parameter)
{
// Clear effect parameter
target.param = 0;
}
if((mask.command || mask.parameter) && (target.IsPcNote()))
{
target.SetValueEffectCol(0);
}
SetSelToCursor();
if(target != oldcmd)
{
SetModified(false);
InvalidateRow();
UpdateIndicator();
}
if(step && (sndFile->IsPaused() || !m_Status[psFollowSong] ||
(CMainFrame::GetMainFrame() != nullptr && CMainFrame::GetMainFrame()->GetFollowSong(GetDocument()) != m_hWnd)))
{
// Preview Row
if((TrackerSettings::Instance().m_dwPatternSetup & PATTERN_PLAYEDITROW) && !IsLiveRecord())
{
PatternStep(GetCurrentRow());
}
if(m_nSpacing > 0)
SetCurrentRow(GetCurrentRow() + m_nSpacing);
SetSelToCursor();
}
}
void CViewPattern::OnInitMenu(CMenu *pMenu)
{
CModScrollView::OnInitMenu(pMenu);
}
void CViewPattern::TogglePluginEditor(int chan)
{
CModDoc *modDoc = GetDocument();
if(!modDoc)
return;
int plug = modDoc->GetSoundFile().ChnSettings[chan].nMixPlugin;
if(plug > 0)
modDoc->TogglePluginEditor(plug - 1);
return;
}
void CViewPattern::OnSelectInstrument(UINT nID)
{
SetSelectionInstrument(static_cast<INSTRUMENTINDEX>(nID - ID_CHANGE_INSTRUMENT), true);
}
void CViewPattern::OnSelectPCNoteParam(UINT nID)
{
CSoundFile *sndFile = GetSoundFile();
if(sndFile == nullptr || !sndFile->Patterns.IsValidPat(m_nPattern))
return;
uint16 paramNdx = static_cast<uint16>(nID - ID_CHANGE_PCNOTE_PARAM);
bool modified = false;
ApplyToSelection([paramNdx, &modified] (ModCommand &m, ROWINDEX, CHANNELINDEX)
{
if(m.IsPcNote() && (m.GetValueVolCol() != paramNdx))
{
m.SetValueVolCol(paramNdx);
modified = true;
}
});
if(modified)
{
SetModified();
InvalidatePattern();
}
}
void CViewPattern::OnSelectPlugin(UINT nID)
{
CSoundFile *sndFile = GetSoundFile();
if(sndFile == nullptr)
return;
const CHANNELINDEX plugChannel = m_MenuCursor.GetChannel();
if(plugChannel < sndFile->GetNumChannels())
{
PLUGINDEX newPlug = static_cast<PLUGINDEX>(nID - ID_PLUGSELECT);
if(newPlug <= MAX_MIXPLUGINS && newPlug != sndFile->ChnSettings[plugChannel].nMixPlugin)
{
sndFile->ChnSettings[plugChannel].nMixPlugin = newPlug;
if(sndFile->GetModSpecifications().supportsPlugins)
{
SetModified(false);
}
InvalidateChannelsHeaders();
}
}
}
bool CViewPattern::HandleSplit(ModCommand &m, int note)
{
ModCommand::INSTR ins = static_cast<ModCommand::INSTR>(GetCurrentInstrument());
const bool isSplit = IsNoteSplit(note);
if(isSplit)
{
CModDoc *modDoc = GetDocument();
if(modDoc == nullptr)
return false;
const CSoundFile &sndFile = modDoc->GetSoundFile();
if(modDoc->GetSplitKeyboardSettings().octaveLink && note <= NOTE_MAX)
{
note += 12 * modDoc->GetSplitKeyboardSettings().octaveModifier;
Limit(note, sndFile.GetModSpecifications().noteMin, sndFile.GetModSpecifications().noteMax);
}
if(modDoc->GetSplitKeyboardSettings().splitInstrument)
{
ins = modDoc->GetSplitKeyboardSettings().splitInstrument;
}
}
m.note = static_cast<ModCommand::NOTE>(note);
if(ins)
{
m.instr = ins;
}
return isSplit;
}
bool CViewPattern::IsNoteSplit(int note) const
{
CModDoc *pModDoc = GetDocument();
return (pModDoc != nullptr
&& pModDoc->GetSplitKeyboardSettings().IsSplitActive()
&& note <= pModDoc->GetSplitKeyboardSettings().splitNote);
}
bool CViewPattern::BuildPluginCtxMenu(HMENU hMenu, UINT nChn, const CSoundFile &sndFile) const
{
for(PLUGINDEX plug = 0; plug <= MAX_MIXPLUGINS; plug++)
{
bool itemFound = false;
CString s;
if(!plug)
{
s = _T("No Plugin");
itemFound = true;
} else
{
const SNDMIXPLUGIN &plugin = sndFile.m_MixPlugins[plug - 1];
if(plugin.IsValidPlugin())
{
s.Format(_T("FX%u: "), plug);
s += mpt::ToCString(plugin.GetName());
itemFound = true;
}
}
if(itemFound)
{
UINT flags = MF_STRING | ((plug == sndFile.ChnSettings[nChn].nMixPlugin) ? MF_CHECKED : 0);
AppendMenu(hMenu, flags, ID_PLUGSELECT + plug, s);
}
}
return true;
}
bool CViewPattern::BuildSoloMuteCtxMenu(HMENU hMenu, CInputHandler *ih, UINT nChn, const CSoundFile &sndFile) const
{
AppendMenu(hMenu, sndFile.ChnSettings[nChn].dwFlags[CHN_MUTE] ? (MF_STRING | MF_CHECKED) : MF_STRING, ID_PATTERN_MUTE, ih->GetKeyTextFromCommand(kcChannelMute, _T("&Mute Channel")));
bool solo = false, unmuteAll = false;
bool soloPending = false, unmuteAllPending = false; // doesn't work perfectly yet
for(CHANNELINDEX i = 0; i < sndFile.GetNumChannels(); i++)
{
if(i != nChn)
{
if(!sndFile.ChnSettings[i].dwFlags[CHN_MUTE])
solo = soloPending = true;
if(sndFile.ChnSettings[i].dwFlags[CHN_MUTE] && sndFile.m_bChannelMuteTogglePending[i])
soloPending = true;
} else
{
if(sndFile.ChnSettings[i].dwFlags[CHN_MUTE])
solo = soloPending = true;
if(!sndFile.ChnSettings[i].dwFlags[CHN_MUTE] && sndFile.m_bChannelMuteTogglePending[i])
soloPending = true;
}
if(sndFile.ChnSettings[i].dwFlags[CHN_MUTE])
unmuteAll = unmuteAllPending = true;
if(!sndFile.ChnSettings[i].dwFlags[CHN_MUTE] && sndFile.m_bChannelMuteTogglePending[i])
unmuteAllPending = true;
}
if(solo)
AppendMenu(hMenu, MF_STRING, ID_PATTERN_SOLO, ih->GetKeyTextFromCommand(kcChannelSolo, _T("&Solo Channel")));
if(unmuteAll)
AppendMenu(hMenu, MF_STRING, ID_PATTERN_UNMUTEALL, ih->GetKeyTextFromCommand(kcChannelUnmuteAll, _T("&Unmute All")));
AppendMenu(hMenu, sndFile.m_bChannelMuteTogglePending[nChn] ? (MF_STRING | MF_CHECKED) : MF_STRING, ID_PATTERN_TRANSITIONMUTE, ih->GetKeyTextFromCommand(kcToggleChanMuteOnPatTransition, sndFile.ChnSettings[nChn].dwFlags[CHN_MUTE] ? _T("On Transition: Unmute\t") : _T("On Transition: Mute\t")));
if(unmuteAllPending)
AppendMenu(hMenu, MF_STRING, ID_PATTERN_TRANSITION_UNMUTEALL, ih->GetKeyTextFromCommand(kcUnmuteAllChnOnPatTransition, _T("On Transition: Unmute All")));
if(soloPending)
AppendMenu(hMenu, MF_STRING, ID_PATTERN_TRANSITIONSOLO, ih->GetKeyTextFromCommand(kcSoloChnOnPatTransition, _T("On Transition: Solo")));
AppendMenu(hMenu, MF_STRING, ID_PATTERN_CHNRESET, ih->GetKeyTextFromCommand(kcChannelReset, _T("&Reset Channel")));
return true;
}
bool CViewPattern::BuildRecordCtxMenu(HMENU hMenu, CInputHandler *ih, CHANNELINDEX nChn) const
{
const auto recordGroup = GetDocument()->GetChannelRecordGroup(nChn);
AppendMenu(hMenu, (recordGroup == RecordGroup::Group1) ? (MF_STRING | MF_CHECKED) : MF_STRING, ID_EDIT_RECSELECT, ih->GetKeyTextFromCommand(kcChannelRecordSelect, _T("R&ecord Select")));
AppendMenu(hMenu, (recordGroup == RecordGroup::Group2) ? (MF_STRING | MF_CHECKED) : MF_STRING, ID_EDIT_SPLITRECSELECT, ih->GetKeyTextFromCommand(kcChannelSplitRecordSelect, _T("S&plit Record Select")));
return true;
}
bool CViewPattern::BuildRowInsDelCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
HMENU subMenuInsert = CreatePopupMenu();
HMENU subMenuDelete = CreatePopupMenu();
const auto numRows = m_Selection.GetNumRows();
const CString label = (numRows != 1) ? MPT_CFORMAT("{} Rows")(numRows) : CString(_T("Row"));
AppendMenu(subMenuInsert, MF_STRING, ID_PATTERN_INSERTROW, ih->GetKeyTextFromCommand(kcInsertRow, _T("Insert ") + label + _T(" (&Selection)")));
AppendMenu(subMenuInsert, MF_STRING, ID_PATTERN_INSERTALLROW, ih->GetKeyTextFromCommand(kcInsertWholeRow, _T("Insert ") + label + _T(" (&All Channels)")));
AppendMenu(subMenuInsert, MF_STRING, ID_PATTERN_INSERTROWGLOBAL, ih->GetKeyTextFromCommand(kcInsertRowGlobal, _T("Insert ") + label + _T(" (Selection, &Global)")));
AppendMenu(subMenuInsert, MF_STRING, ID_PATTERN_INSERTALLROWGLOBAL, ih->GetKeyTextFromCommand(kcInsertWholeRowGlobal, _T("Insert ") + label + _T(" (All &Channels, Global)")));
AppendMenu(hMenu, MF_POPUP, reinterpret_cast<UINT_PTR>(subMenuInsert), _T("&Insert ") + label);
AppendMenu(subMenuDelete, MF_STRING, ID_PATTERN_DELETEROW, ih->GetKeyTextFromCommand(kcDeleteRow, _T("Delete ") + label + _T(" (&Selection)")));
AppendMenu(subMenuDelete, MF_STRING, ID_PATTERN_DELETEALLROW, ih->GetKeyTextFromCommand(kcDeleteWholeRow, _T("Delete ") + label + _T(" (&All Channels)")));
AppendMenu(subMenuDelete, MF_STRING, ID_PATTERN_DELETEROWGLOBAL, ih->GetKeyTextFromCommand(kcDeleteRowGlobal, _T("Delete ") + label + _T(" (Selection, &Global)")));
AppendMenu(subMenuDelete, MF_STRING, ID_PATTERN_DELETEALLROWGLOBAL, ih->GetKeyTextFromCommand(kcDeleteWholeRowGlobal, _T("Delete ") + label + _T(" (All &Channels, Global)")));
AppendMenu(hMenu, MF_POPUP, reinterpret_cast<UINT_PTR>(subMenuDelete), _T("&Delete ") + label);
return true;
}
bool CViewPattern::BuildMiscCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
AppendMenu(hMenu, MF_STRING, ID_SHOWTIMEATROW, ih->GetKeyTextFromCommand(kcTimeAtRow, _T("Show Row Play Time")));
if(m_Selection.GetStartRow() == m_Selection.GetEndRow())
{
CString s;
s.Format(_T("Split Pattern at Ro&w %u"), m_Selection.GetStartRow());
AppendMenu(hMenu, MF_STRING | (m_Selection.GetStartRow() < 1 ? MF_GRAYED : 0), ID_PATTERN_SPLIT, ih->GetKeyTextFromCommand(kcSplitPattern, s));
}
const CSoundFile &sndFile = *GetSoundFile();
CString lockStr;
bool lockActive = (sndFile.m_lockRowStart != ROWINDEX_INVALID);
if(m_Selection.GetUpperLeft() != m_Selection.GetLowerRight())
{
lockStr = _T("&Lock Playback to Selection");
if(lockActive)
{
lockStr.AppendFormat(_T(" (Current: %u-%u)"), sndFile.m_lockRowStart, sndFile.m_lockRowEnd);
}
} else if(lockActive)
{
lockStr = _T("Reset Playback &Lock");
} else
{
return true;
}
AppendMenu(hMenu, MF_STRING | (lockActive ? MF_CHECKED : 0), ID_LOCK_PATTERN_ROWS, ih->GetKeyTextFromCommand(kcLockPlaybackToRows, lockStr));
return true;
}
bool CViewPattern::BuildSelectionCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
AppendMenu(hMenu, MF_STRING, ID_EDIT_SELECTCOLUMN, ih->GetKeyTextFromCommand(kcSelectChannel, _T("Select &Channel")));
AppendMenu(hMenu, MF_STRING, ID_EDIT_SELECT_ALL, ih->GetKeyTextFromCommand(kcEditSelectAll, _T("Select &Pattern")));
return true;
}
bool CViewPattern::BuildGrowShrinkCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
AppendMenu(hMenu, MF_STRING, ID_GROW_SELECTION, ih->GetKeyTextFromCommand(kcPatternGrowSelection, _T("&Grow selection")));
AppendMenu(hMenu, MF_STRING, ID_SHRINK_SELECTION, ih->GetKeyTextFromCommand(kcPatternShrinkSelection, _T("&Shrink selection")));
return true;
}
bool CViewPattern::BuildInterpolationCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
const CSoundFile *sndFile = GetSoundFile();
const bool isPCNote = sndFile->Patterns.IsValidPat(m_nPattern) && sndFile->Patterns[m_nPattern].GetpModCommand(m_Selection.GetStartRow(), m_Selection.GetStartChannel())->IsPcNote();
HMENU subMenu = CreatePopupMenu();
bool possible = BuildInterpolationCtxMenu(subMenu, PatternCursor::noteColumn, ih->GetKeyTextFromCommand(kcPatternInterpolateNote, _T("&Note Column")), ID_PATTERN_INTERPOLATE_NOTE)
| BuildInterpolationCtxMenu(subMenu, PatternCursor::instrColumn, ih->GetKeyTextFromCommand(kcPatternInterpolateInstr, isPCNote ? _T("&Plugin Column") : _T("&Instrument Column")), ID_PATTERN_INTERPOLATE_INSTR)
| BuildInterpolationCtxMenu(subMenu, PatternCursor::volumeColumn, ih->GetKeyTextFromCommand(kcPatternInterpolateVol, isPCNote ? _T("&Parameter Column") : _T("&Volume Column")), ID_PATTERN_INTERPOLATE_VOLUME)
| BuildInterpolationCtxMenu(subMenu, PatternCursor::effectColumn, ih->GetKeyTextFromCommand(kcPatternInterpolateEffect, isPCNote ? _T("&Value Column") : _T("&Effect Column")), ID_PATTERN_INTERPOLATE_EFFECT);
if(possible || !(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_OLDCTXMENUSTYLE))
{
AppendMenu(hMenu, MF_POPUP | (possible ? 0 : MF_GRAYED), reinterpret_cast<UINT_PTR>(subMenu), _T("I&nterpolate..."));
return true;
}
return false;
}
bool CViewPattern::BuildInterpolationCtxMenu(HMENU hMenu, PatternCursor::Columns colType, CString label, UINT command) const
{
bool possible = IsInterpolationPossible(colType);
if(!possible && colType == PatternCursor::effectColumn)
{
// Extend search to param column
possible = IsInterpolationPossible(PatternCursor::paramColumn);
}
if(possible || !(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_OLDCTXMENUSTYLE))
{
AppendMenu(hMenu, MF_STRING | (possible ? 0 : MF_GRAYED), command, label);
}
return possible;
}
bool CViewPattern::BuildEditCtxMenu(HMENU hMenu, CInputHandler *ih, CModDoc *pModDoc) const
{
HMENU pasteSpecialMenu = ::CreatePopupMenu();
AppendMenu(hMenu, MF_STRING, ID_EDIT_CUT, ih->GetKeyTextFromCommand(kcEditCut, _T("Cu&t")));
AppendMenu(hMenu, MF_STRING, ID_EDIT_COPY, ih->GetKeyTextFromCommand(kcEditCopy, _T("&Copy")));
AppendMenu(hMenu, MF_STRING | (PatternClipboard::CanPaste() ? 0 : MF_GRAYED), ID_EDIT_PASTE, ih->GetKeyTextFromCommand(kcEditPaste, _T("&Paste")));
AppendMenu(hMenu, MF_POPUP, reinterpret_cast<UINT_PTR>(pasteSpecialMenu), _T("Paste Special"));
AppendMenu(pasteSpecialMenu, MF_STRING, ID_EDIT_MIXPASTE, ih->GetKeyTextFromCommand(kcEditMixPaste, _T("&Mix Paste")));
AppendMenu(pasteSpecialMenu, MF_STRING, ID_EDIT_MIXPASTE_ITSTYLE, ih->GetKeyTextFromCommand(kcEditMixPasteITStyle, _T("M&ix Paste (IT Style)")));
AppendMenu(pasteSpecialMenu, MF_STRING, ID_EDIT_PASTEFLOOD, ih->GetKeyTextFromCommand(kcEditPasteFlood, _T("Paste Fl&ood")));
AppendMenu(pasteSpecialMenu, MF_STRING, ID_EDIT_PUSHFORWARDPASTE, ih->GetKeyTextFromCommand(kcEditPushForwardPaste, _T("&Push Forward Paste (Insert)")));
DWORD greyed = pModDoc->GetPatternUndo().CanUndo() ? MF_ENABLED : MF_GRAYED;
if(!greyed || !(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_OLDCTXMENUSTYLE))
{
AppendMenu(hMenu, MF_STRING | greyed, ID_EDIT_UNDO, ih->GetKeyTextFromCommand(kcEditUndo, _T("&Undo")));
}
greyed = pModDoc->GetPatternUndo().CanRedo() ? MF_ENABLED : MF_GRAYED;
if(!greyed || !(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_OLDCTXMENUSTYLE))
{
AppendMenu(hMenu, MF_STRING | greyed, ID_EDIT_REDO, ih->GetKeyTextFromCommand(kcEditRedo, _T("&Redo")));
}
AppendMenu(hMenu, MF_STRING, ID_CLEAR_SELECTION, ih->GetKeyTextFromCommand(kcSampleDelete, _T("Clear Selection")));
return true;
}
bool CViewPattern::BuildVisFXCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
DWORD greyed = (IsColumnSelected(PatternCursor::effectColumn) || IsColumnSelected(PatternCursor::paramColumn)) ? FALSE : MF_GRAYED;
if(!greyed || !(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_OLDCTXMENUSTYLE))
{
AppendMenu(hMenu, MF_STRING | greyed, ID_PATTERN_VISUALIZE_EFFECT, ih->GetKeyTextFromCommand(kcPatternVisualizeEffect, _T("&Visualize Effect")));
return true;
}
return false;
}
bool CViewPattern::BuildTransposeCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
HMENU transMenu = CreatePopupMenu();
std::vector<CHANNELINDEX> validChans;
DWORD greyed = IsColumnSelected(PatternCursor::noteColumn) ? FALSE : MF_GRAYED;
if(!greyed || !(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_OLDCTXMENUSTYLE))
{
AppendMenu(transMenu, MF_STRING | greyed, ID_TRANSPOSE_UP, ih->GetKeyTextFromCommand(kcTransposeUp, _T("Transpose +&1")));
AppendMenu(transMenu, MF_STRING | greyed, ID_TRANSPOSE_DOWN, ih->GetKeyTextFromCommand(kcTransposeDown, _T("Transpose -&1")));
AppendMenu(transMenu, MF_STRING | greyed, ID_TRANSPOSE_OCTUP, ih->GetKeyTextFromCommand(kcTransposeOctUp, _T("Transpose +1&2")));
AppendMenu(transMenu, MF_STRING | greyed, ID_TRANSPOSE_OCTDOWN, ih->GetKeyTextFromCommand(kcTransposeOctDown, _T("Transpose -1&2")));
AppendMenu(transMenu, MF_STRING | greyed, ID_TRANSPOSE_CUSTOM, ih->GetKeyTextFromCommand(kcTransposeCustom, _T("&Custom...")));
AppendMenu(hMenu, MF_POPUP | greyed, reinterpret_cast<UINT_PTR>(transMenu), _T("&Transpose..."));
return true;
}
return false;
}
bool CViewPattern::BuildAmplifyCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
std::vector<CHANNELINDEX> validChans;
DWORD greyed = IsColumnSelected(PatternCursor::volumeColumn) ? 0 : MF_GRAYED;
if(!greyed || !(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_OLDCTXMENUSTYLE))
{
AppendMenu(hMenu, MF_STRING | greyed, ID_PATTERN_AMPLIFY, ih->GetKeyTextFromCommand(kcPatternAmplify, _T("&Amplify")));
return true;
}
return false;
}
bool CViewPattern::BuildChannelControlCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
const CModSpecifications &specs = GetDocument()->GetSoundFile().GetModSpecifications();
CHANNELINDEX numChannels = GetDocument()->GetNumChannels();
DWORD canAddChannels = (numChannels < specs.channelsMax) ? 0 : MF_GRAYED;
DWORD canRemoveChannels = (numChannels > specs.channelsMin) ? 0 : MF_GRAYED;
AppendMenu(hMenu, MF_SEPARATOR, 0, _T(""));
AppendMenu(hMenu, MF_STRING, ID_PATTERN_TRANSPOSECHANNEL, ih->GetKeyTextFromCommand(kcChannelTranspose, _T("&Transpose Channel")));
AppendMenu(hMenu, MF_STRING | canAddChannels, ID_PATTERN_DUPLICATECHANNEL, ih->GetKeyTextFromCommand(kcChannelDuplicate, _T("&Duplicate Channel")));
HMENU addChannelMenu = ::CreatePopupMenu();
AppendMenu(hMenu, MF_POPUP | canAddChannels, reinterpret_cast<UINT_PTR>(addChannelMenu), _T("&Add Channel\t"));
AppendMenu(addChannelMenu, MF_STRING, ID_PATTERN_ADDCHANNEL_FRONT, ih->GetKeyTextFromCommand(kcChannelAddBefore, _T("&Before this channel")));
AppendMenu(addChannelMenu, MF_STRING, ID_PATTERN_ADDCHANNEL_AFTER, ih->GetKeyTextFromCommand(kcChannelAddAfter, _T("&After this channel")));
HMENU removeChannelMenu = ::CreatePopupMenu();
AppendMenu(hMenu, MF_POPUP | canRemoveChannels, reinterpret_cast<UINT_PTR>(removeChannelMenu), _T("Remo&ve Channel\t"));
AppendMenu(removeChannelMenu, MF_STRING, ID_PATTERN_REMOVECHANNEL, ih->GetKeyTextFromCommand(kcChannelRemove, _T("&Remove this channel\t")));
AppendMenu(removeChannelMenu, MF_STRING, ID_PATTERN_REMOVECHANNELDIALOG, _T("&Choose channels to remove...\t"));
AppendMenu(hMenu, MF_STRING, ID_PATTERN_RESETCHANNELCOLORS, _T("Reset Channel &Colours"));
return false;
}
bool CViewPattern::BuildSetInstCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
const CSoundFile *sndFile = GetSoundFile();
const CModDoc *modDoc;
if(sndFile == nullptr || (modDoc = sndFile->GetpModDoc()) == nullptr)
{
return false;
}
std::vector<CHANNELINDEX> validChans;
DWORD greyed = IsColumnSelected(PatternCursor::instrColumn) ? 0 : MF_GRAYED;
if(!greyed || !(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_OLDCTXMENUSTYLE))
{
if((sndFile->Patterns.IsValidPat(m_nPattern)))
{
if(sndFile->Patterns[m_nPattern].GetpModCommand(m_Selection.GetStartRow(), m_Selection.GetStartChannel())->IsPcNote())
{
// Don't build instrument menu for PC notes.
return false;
}
}
// Create the new menu and add it to the existing menu.
HMENU instrumentChangeMenu = ::CreatePopupMenu();
AppendMenu(hMenu, MF_POPUP | greyed, reinterpret_cast<UINT_PTR>(instrumentChangeMenu), ih->GetKeyTextFromCommand(kcPatternSetInstrument, _T("Change Instrument")));
if(!greyed)
{
bool addSeparator = false;
if(sndFile->GetNumInstruments())
{
for(INSTRUMENTINDEX i = 1; i <= sndFile->GetNumInstruments(); i++)
{
if(sndFile->Instruments[i] == nullptr)
continue;
CString instString = modDoc->GetPatternViewInstrumentName(i, true);
if(!instString.IsEmpty())
{
AppendMenu(instrumentChangeMenu, MF_STRING, ID_CHANGE_INSTRUMENT + i, modDoc->GetPatternViewInstrumentName(i));
addSeparator = true;
}
}
} else
{
CString s;
for(SAMPLEINDEX i = 1; i <= sndFile->GetNumSamples(); i++) if (sndFile->GetSample(i).HasSampleData())
{
s.Format(_T("%02d: "), i);
s += mpt::ToCString(sndFile->GetCharsetInternal(), sndFile->GetSampleName(i));
AppendMenu(instrumentChangeMenu, MF_STRING, ID_CHANGE_INSTRUMENT + i, s);
addSeparator = true;
}
}
// Add options to remove instrument from selection.
if(addSeparator)
{
AppendMenu(instrumentChangeMenu, MF_SEPARATOR, 0, 0);
}
AppendMenu(instrumentChangeMenu, MF_STRING, ID_CHANGE_INSTRUMENT, _T("&Remove Instrument"));
AppendMenu(instrumentChangeMenu, MF_STRING, ID_CHANGE_INSTRUMENT + GetCurrentInstrument(), ih->GetKeyTextFromCommand(kcPatternSetInstrument, _T("&Current Instrument")));
AppendMenu(instrumentChangeMenu, MF_STRING, ID_PATTERN_SETINSTRUMENT, ih->GetKeyTextFromCommand(kcPatternSetInstrumentNotEmpty, _T("Current Instrument (&only change existing)")));
}
return BuildTogglePlugEditorCtxMenu(hMenu, ih);
}
return false;
}
// Context menu for Param Control notes
bool CViewPattern::BuildPCNoteCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
const CSoundFile *sndFile = GetSoundFile();
if(sndFile == nullptr || !sndFile->Patterns.IsValidPat(m_nPattern))
{
return false;
}
const ModCommand &selStart = *sndFile->Patterns[m_nPattern].GetpModCommand(m_Selection.GetStartRow(), m_Selection.GetStartChannel());
if(!selStart.IsPcNote())
{
return false;
}
CString s;
// Create sub menu for "change plugin"
HMENU pluginChangeMenu = ::CreatePopupMenu();
AppendMenu(hMenu, MF_POPUP, reinterpret_cast<UINT_PTR>(pluginChangeMenu), ih->GetKeyTextFromCommand(kcPatternSetInstrument, _T("Change Plugin")));
for(PLUGINDEX nPlg = 0; nPlg < MAX_MIXPLUGINS; nPlg++)
{
if(sndFile->m_MixPlugins[nPlg].pMixPlugin != nullptr)
{
s = MPT_CFORMAT("{}: {}")(mpt::cfmt::dec0<2>(nPlg + 1), mpt::ToCString(sndFile->m_MixPlugins[nPlg].GetName()));
AppendMenu(pluginChangeMenu, MF_STRING | (((nPlg + 1) == selStart.instr) ? MF_CHECKED : 0), ID_CHANGE_INSTRUMENT + nPlg + 1, s);
}
}
if(selStart.instr >= 1 && selStart.instr <= MAX_MIXPLUGINS)
{
const SNDMIXPLUGIN &plug = sndFile->m_MixPlugins[selStart.instr - 1];
if(plug.pMixPlugin != nullptr)
{
// Create sub menu for "change plugin param"
HMENU paramChangeMenu = ::CreatePopupMenu();
AppendMenu(hMenu, MF_POPUP, reinterpret_cast<UINT_PTR>(paramChangeMenu), _T("Change Plugin Parameter\t"));
const PlugParamIndex curParam = selStart.GetValueVolCol(), nParams = plug.pMixPlugin->GetNumParameters();
for(PlugParamIndex i = 0; i < nParams; i++)
{
AppendMenu(paramChangeMenu, MF_STRING | ((i == curParam) ? MF_CHECKED : 0), ID_CHANGE_PCNOTE_PARAM + i, plug.pMixPlugin->GetFormattedParamName(i));
}
}
}
return BuildTogglePlugEditorCtxMenu(hMenu, ih);
}
bool CViewPattern::BuildTogglePlugEditorCtxMenu(HMENU hMenu, CInputHandler *ih) const
{
const CSoundFile *sndFile = GetSoundFile();
if(sndFile == nullptr || !sndFile->Patterns.IsValidPat(m_nPattern))
{
return false;
}
PLUGINDEX plug = 0;
const ModCommand &selStart = *sndFile->Patterns[m_nPattern].GetpModCommand(m_Selection.GetStartRow(), m_Selection.GetStartChannel());
if(selStart.IsPcNote())
{
// PC Event
plug = selStart.instr;
} else if(selStart.instr > 0 && selStart.instr <= sndFile->GetNumInstruments()
&& sndFile->Instruments[selStart.instr] != nullptr
&& sndFile->Instruments[selStart.instr]->nMixPlug)
{
// Regular instrument
plug = sndFile->Instruments[selStart.instr]->nMixPlug;
}
if(plug && plug <= MAX_MIXPLUGINS && sndFile->m_MixPlugins[plug - 1].pMixPlugin != nullptr)
{
AppendMenu(hMenu, MF_STRING, ID_PATTERN_EDIT_PCNOTE_PLUGIN, ih->GetKeyTextFromCommand(kcPatternEditPCNotePlugin, _T("Toggle Plugin &Editor")));
return true;
}
return false;
}
// Returns an ordered list of all channels in which a given column type is selected.
CHANNELINDEX CViewPattern::ListChansWhereColSelected(PatternCursor::Columns colType, std::vector<CHANNELINDEX> &chans) const
{
CHANNELINDEX startChan = m_Selection.GetStartChannel();
CHANNELINDEX endChan = m_Selection.GetEndChannel();
chans.clear();
chans.reserve(endChan - startChan + 1);
// Check in which channels this column is selected.
// Actually this check is only important for the first and last channel, but to keep things clean and simple, all channels are checked in the same manner.
for(CHANNELINDEX i = startChan; i <= endChan; i++)
{
if(m_Selection.ContainsHorizontal(PatternCursor(0, i, colType)))
{
chans.push_back(i);
}
}
return static_cast<CHANNELINDEX>(chans.size());
}
// Check if a column type is selected on any channel in the current selection.
bool CViewPattern::IsColumnSelected(PatternCursor::Columns colType) const
{
return m_Selection.ContainsHorizontal(PatternCursor(0, m_Selection.GetStartChannel(), colType))
|| m_Selection.ContainsHorizontal(PatternCursor(0, m_Selection.GetEndChannel(), colType));
}
// Check if the given interpolation type is actually possible in the current selection.
bool CViewPattern::IsInterpolationPossible(PatternCursor::Columns colType) const
{
std::vector<CHANNELINDEX> validChans;
ListChansWhereColSelected(colType, validChans);
ROWINDEX startRow = m_Selection.GetStartRow();
ROWINDEX endRow = m_Selection.GetEndRow();
for(auto chn : validChans)
{
if(IsInterpolationPossible(startRow, endRow, chn, colType))
{
return true;
}
}
return false;
}
// Check if the given interpolation type is actually possible in a given channel.
bool CViewPattern::IsInterpolationPossible(ROWINDEX startRow, ROWINDEX endRow, CHANNELINDEX chan, PatternCursor::Columns colType) const
{
const CSoundFile *sndFile = GetSoundFile();
if(startRow == endRow || sndFile == nullptr || !sndFile->Patterns.IsValidPat(m_nPattern))
return false;
bool result = false;
const ModCommand &startRowMC = *sndFile->Patterns[m_nPattern].GetpModCommand(startRow, chan);
const ModCommand &endRowMC = *sndFile->Patterns[m_nPattern].GetpModCommand(endRow, chan);
UINT startRowCmd, endRowCmd;
if(colType == PatternCursor::effectColumn && (startRowMC.IsPcNote() || endRowMC.IsPcNote()))
return true;
switch(colType)
{
case PatternCursor::noteColumn:
startRowCmd = startRowMC.note;
endRowCmd = endRowMC.note;
result = (startRowCmd == endRowCmd && startRowCmd != NOTE_NONE) // Interpolate between two identical notes or Cut / Fade / etc...
|| (startRowCmd != NOTE_NONE && endRowCmd == NOTE_NONE) // Fill in values from the first row
|| (startRowCmd == NOTE_NONE && endRowCmd != NOTE_NONE) // Fill in values from the last row
|| (ModCommand::IsNoteOrEmpty(startRowMC.note) && ModCommand::IsNoteOrEmpty(endRowMC.note) && !(startRowCmd == NOTE_NONE && endRowCmd == NOTE_NONE)); // Interpolate between two notes of which one may be empty
break;
case PatternCursor::instrColumn:
startRowCmd = startRowMC.instr;
endRowCmd = endRowMC.instr;
result = startRowCmd != 0 || endRowCmd != 0;
break;
case PatternCursor::volumeColumn:
startRowCmd = startRowMC.volcmd;
endRowCmd = endRowMC.volcmd;
result = (startRowCmd == endRowCmd && startRowCmd != VOLCMD_NONE) // Interpolate between two identical commands
|| (startRowCmd != VOLCMD_NONE && endRowCmd == VOLCMD_NONE) // Fill in values from the first row
|| (startRowCmd == VOLCMD_NONE && endRowCmd != VOLCMD_NONE); // Fill in values from the last row
break;
case PatternCursor::effectColumn:
case PatternCursor::paramColumn:
startRowCmd = startRowMC.command;
endRowCmd = endRowMC.command;
result = (startRowCmd == endRowCmd && startRowCmd != CMD_NONE) // Interpolate between two identical commands
|| (startRowCmd != CMD_NONE && endRowCmd == CMD_NONE) // Fill in values from the first row
|| (startRowCmd == CMD_NONE && endRowCmd != CMD_NONE); // Fill in values from the last row
break;
default:
result = false;
}
return result;
}
void CViewPattern::OnRButtonDblClk(UINT nFlags, CPoint point)
{
OnRButtonDown(nFlags, point);
CModScrollView::OnRButtonDblClk(nFlags, point);
}
// Toggle pending mute status for channel from context menu.
void CViewPattern::OnTogglePendingMuteFromClick()
{
TogglePendingMute(m_MenuCursor.GetChannel());
}
// Toggle pending solo status for channel from context menu.
void CViewPattern::OnPendingSoloChnFromClick()
{
PendingSoloChn(m_MenuCursor.GetChannel());
}
// Set pending unmute status for all channels.
void CViewPattern::OnPendingUnmuteAllChnFromClick()
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr)
{
GetSoundFile()->PatternTransitionChnUnmuteAll();
InvalidateChannelsHeaders();
}
}
// Toggle pending solo status for a channel.
void CViewPattern::PendingSoloChn(CHANNELINDEX nChn)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr)
{
GetSoundFile()->PatternTranstionChnSolo(nChn);
InvalidateChannelsHeaders();
}
}
// Toggle pending mute status for a channel.
void CViewPattern::TogglePendingMute(CHANNELINDEX nChn)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile != nullptr)
{
pSndFile->m_bChannelMuteTogglePending[nChn] = !pSndFile->m_bChannelMuteTogglePending[nChn];
InvalidateChannelsHeaders();
}
}
// Check if editing is enabled, and if it's not, prompt the user to enable editing.
bool CViewPattern::IsEditingEnabled_bmsg()
{
if(IsEditingEnabled())
return true;
if(TrackerSettings::Instance().patternNoEditPopup)
return false;
HMENU hMenu;
if((hMenu = ::CreatePopupMenu()) == nullptr)
return false;
CPoint pt = GetPointFromPosition(m_Cursor);
// We add an mnemonic for an unbreakable space to avoid activating edit mode accidentally.
AppendMenuW(hMenu, MF_STRING, IDC_PATTERN_RECORD, L"Editing (recording) is disabled;&\u00A0 click here to enable it.");
ClientToScreen(&pt);
::TrackPopupMenu(hMenu, TPM_LEFTALIGN, pt.x, pt.y, 0, m_hWnd, NULL);
::DestroyMenu(hMenu);
return false;
}
// Show playback time at a given pattern position.
void CViewPattern::OnShowTimeAtRow()
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr)
{
return;
}
CString msg;
const auto &order = Order();
ORDERINDEX currentOrder = GetCurrentOrder();
if(currentOrder < order.size() && order[currentOrder] == m_nPattern)
{
const double t = pSndFile->GetPlaybackTimeAt(currentOrder, GetCurrentRow(), false, false);
if(t < 0)
msg.Format(_T("Unable to determine the time. Possible cause: No order %d, row %u found in play sequence."), currentOrder, GetCurrentRow());
else
{
const uint32 minutes = static_cast<uint32>(t / 60.0);
const double seconds = t - (minutes * 60);
msg.Format(_T("Estimate for playback time at order %d (pattern %d), row %u: %u minute%s %.2f seconds."), currentOrder, m_nPattern, GetCurrentRow(), minutes, (minutes == 1) ? _T("") : _T("s"), seconds);
}
} else
{
msg.Format(_T("Unable to determine the time: pattern at current order (%d) does not correspond to pattern in pattern view (pattern %d)."), currentOrder, m_nPattern);
}
Reporting::Notification(msg);
}
// Set up split keyboard
void CViewPattern::SetSplitKeyboardSettings()
{
CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr)
return;
CSplitKeyboardSettings dlg(CMainFrame::GetMainFrame(), pModDoc->GetSoundFile(), pModDoc->GetSplitKeyboardSettings());
if(dlg.DoModal() == IDOK)
{
// Update split keyboard settings in other pattern views
pModDoc->UpdateAllViews(NULL, SampleHint().Names());
}
}
// Paste pattern data using the given paste mode.
void CViewPattern::ExecutePaste(PatternClipboard::PasteModes mode)
{
if(IsEditingEnabled_bmsg() && PastePattern(m_nPattern, m_Selection.GetUpperLeft(), mode))
{
InvalidatePattern(false);
SetFocus();
}
}
// Show plugin editor for plugin assigned to PC Event at the cursor position.
void CViewPattern::OnTogglePCNotePluginEditor()
{
CModDoc *pModDoc = GetDocument();
if(pModDoc == nullptr)
return;
CSoundFile &sndFile = pModDoc->GetSoundFile();
if(!sndFile.Patterns.IsValidPat(m_nPattern))
return;
const ModCommand &m = *sndFile.Patterns[m_nPattern].GetpModCommand(m_Selection.GetStartRow(), m_Selection.GetStartChannel());
PLUGINDEX plug = 0;
if(!m.IsPcNote())
{
// No PC note: Toggle instrument's plugin editor
if(m.instr && m.instr <= sndFile.GetNumInstruments() && sndFile.Instruments[m.instr])
{
plug = sndFile.Instruments[m.instr]->nMixPlug;
}
} else
{
plug = m.instr;
}
if(plug > 0 && plug <= MAX_MIXPLUGINS)
pModDoc->TogglePluginEditor(plug - 1);
}
// Get the active pattern's rows per beat, or, if they are not overriden, the song's default rows per beat.
ROWINDEX CViewPattern::GetRowsPerBeat() const
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidPat(m_nPattern))
return 0;
if(!pSndFile->Patterns[m_nPattern].GetOverrideSignature())
return pSndFile->m_nDefaultRowsPerBeat;
else
return pSndFile->Patterns[m_nPattern].GetRowsPerBeat();
}
// Get the active pattern's rows per measure, or, if they are not overriden, the song's default rows per measure.
ROWINDEX CViewPattern::GetRowsPerMeasure() const
{
const CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidPat(m_nPattern))
return 0;
if(!pSndFile->Patterns[m_nPattern].GetOverrideSignature())
return pSndFile->m_nDefaultRowsPerMeasure;
else
return pSndFile->Patterns[m_nPattern].GetRowsPerMeasure();
}
// Set instrument
void CViewPattern::SetSelectionInstrument(const INSTRUMENTINDEX instr, bool setEmptyInstrument)
{
CSoundFile *pSndFile = GetSoundFile();
if(pSndFile == nullptr || !pSndFile->Patterns.IsValidPat(m_nPattern))
{
return;
}
BeginWaitCursor();
PrepareUndo(m_Selection, "Set Instrument");
bool modified = false;
ApplyToSelection([instr, setEmptyInstrument, &modified] (ModCommand &m, ROWINDEX, CHANNELINDEX)
{
// If a note or an instr is present on the row, do the change, if required.
// Do not set instr if note and instr are both blank,
// but set instr if note is a PC note and instr is blank.
if(((setEmptyInstrument && (m.IsNote() || m.IsPcNote())) || m.instr != 0)
&& (m.instr != instr))
{
m.instr = static_cast<ModCommand::INSTR>(instr);
modified = true;
}
});
if(modified)
{
SetModified();
InvalidatePattern();
}
EndWaitCursor();
}
// Select a whole beat (selectBeat = true) or measure.
void CViewPattern::SelectBeatOrMeasure(bool selectBeat)
{
const ROWINDEX adjust = selectBeat ? GetRowsPerBeat() : GetRowsPerMeasure();
// Snap to start of beat / measure of upper-left corner of current selection
const ROWINDEX startRow = m_Selection.GetStartRow() - (m_Selection.GetStartRow() % adjust);
// Snap to end of beat / measure of lower-right corner of current selection
const ROWINDEX endRow = m_Selection.GetEndRow() + adjust - (m_Selection.GetEndRow() % adjust) - 1;
CHANNELINDEX startChannel = m_Selection.GetStartChannel(), endChannel = m_Selection.GetEndChannel();
PatternCursor::Columns startColumn = PatternCursor::firstColumn, endColumn = PatternCursor::firstColumn;
if(m_Selection.GetUpperLeft() == m_Selection.GetLowerRight())
{
// No selection has been made yet => expand selection to whole channel.
endColumn = PatternCursor::lastColumn; // Extend to param column
} else if(startRow == m_Selection.GetStartRow() && endRow == m_Selection.GetEndRow())
{
// Whole beat or measure is already selected
if(m_Selection.GetStartColumn() == PatternCursor::firstColumn && m_Selection.GetEndColumn() == PatternCursor::lastColumn)
{
// Whole channel is already selected => expand selection to whole row.
startChannel = 0;
startColumn = PatternCursor::firstColumn;
endChannel = MAX_BASECHANNELS;
endColumn = PatternCursor::lastColumn;
} else
{
// Channel is only partly selected => expand to whole channel first.
endColumn = PatternCursor::lastColumn; // Extend to param column
}
} else
{
// Some arbitrary selection: Remember start / end column
startColumn = m_Selection.GetStartColumn();
endColumn = m_Selection.GetEndColumn();
}
SetCurSel(PatternCursor(startRow, startChannel, startColumn), PatternCursor(endRow, endChannel, endColumn));
}
// Sweep pattern channel to find instrument number to use
void CViewPattern::FindInstrument()
{
const CSoundFile *sndFile = GetSoundFile();
if(sndFile == nullptr)
{
return;
}
const auto &order = Order();
ORDERINDEX ord = GetCurrentOrder();
PATTERNINDEX pat = m_nPattern;
ROWINDEX row = m_Cursor.GetRow();
while(sndFile->Patterns.IsValidPat(pat))
{
// Seek upwards
do
{
auto &m = *sndFile->Patterns[pat].GetpModCommand(row, m_Cursor.GetChannel());
if(!m.IsPcNote() && m.instr != 0)
{
SendCtrlMessage(CTRLMSG_SETCURRENTINSTRUMENT, m.instr);
static_cast<CModControlView *>(CWnd::FromHandle(m_hWndCtrl))->InstrumentChanged(m.instr);
return;
}
} while(row-- != 0);
// Try previous pattern
if(ord == 0)
{
return;
}
ord = order.GetPreviousOrderIgnoringSkips(ord);
pat = order[ord];
if(!sndFile->Patterns.IsValidPat(pat))
{
return;
}
row = sndFile->Patterns[pat].GetNumRows() - 1;
}
}
// Find previous or next column entry (note, instrument, ...) on this channel
void CViewPattern::JumpToPrevOrNextEntry(bool nextEntry, bool select)
{
const CSoundFile *sndFile = GetSoundFile();
if(sndFile == nullptr || GetCurrentOrder() >= Order().size())
{
return;
}
const auto &order = Order();
ORDERINDEX ord = GetCurrentOrder();
PATTERNINDEX pat = m_nPattern;
CHANNELINDEX chn = m_Cursor.GetChannel();
PatternCursor::Columns column = m_Cursor.GetColumnType();
int32 row = m_Cursor.GetRow();
int direction = nextEntry ? 1 : -1;
row += direction; // Don't want to find the cell we're already in
while(sndFile->Patterns.IsValidPat(pat))
{
while(sndFile->Patterns[pat].IsValidRow(row))
{
auto &m = *sndFile->Patterns[pat].GetpModCommand(row, chn);
bool found;
switch(column)
{
case PatternCursor::noteColumn:
found = m.note != NOTE_NONE;
break;
case PatternCursor::instrColumn:
found = m.instr != 0;
break;
case PatternCursor::volumeColumn:
found = m.volcmd != VOLCMD_NONE;
break;
case PatternCursor::effectColumn:
case PatternCursor::paramColumn:
found = m.command != CMD_NONE;
break;
default:
found = false;
}
if(found)
{
if(select)
{
CursorJump(static_cast<int>(row) - m_Cursor.GetRow(), false);
} else
{
SetCurrentOrder(ord);
SetCurrentPattern(pat, row);
if(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_PLAYNAVIGATEROW)
{
PatternStep(row);
}
}
return;
}
row += direction;
}
// Continue search in prev/next pattern (unless we also select - selections cannot span multiple patterns)
if(select)
return;
ORDERINDEX nextOrd = nextEntry ? order.GetNextOrderIgnoringSkips(ord) : order.GetPreviousOrderIgnoringSkips(ord);
pat = order[nextOrd];
if(nextOrd == ord || !sndFile->Patterns.IsValidPat(pat))
return;
ord = nextOrd;
row = nextEntry ? 0 : (sndFile->Patterns[pat].GetNumRows() - 1);
}
}
// Copy to clipboard
bool CViewPattern::CopyPattern(PATTERNINDEX nPattern, const PatternRect &selection)
{
BeginWaitCursor();
bool result = PatternClipboard::Copy(*GetSoundFile(), nPattern, selection);
EndWaitCursor();
PatternClipboardDialog::UpdateList();
return result;
}
// Paste from clipboard
bool CViewPattern::PastePattern(PATTERNINDEX nPattern, const PatternCursor &pastePos, PatternClipboard::PasteModes mode)
{
BeginWaitCursor();
PatternEditPos pos;
pos.pattern = nPattern;
pos.row = pastePos.GetRow();
pos.channel = pastePos.GetChannel();
pos.order = GetCurrentOrder();
PatternRect rect;
const bool patternExisted = GetSoundFile()->Patterns.IsValidPat(nPattern);
bool orderChanged = false;
bool result = PatternClipboard::Paste(*GetSoundFile(), pos, mode, rect, orderChanged);
EndWaitCursor();
PatternHint updateHint = PatternHint(PATTERNINDEX_INVALID).Data();
if(pos.pattern != nPattern)
{
// Multipaste: Switch to pasted pattern.
SetCurrentPattern(pos.pattern);
SetCurrentOrder(pos.order);
}
if(orderChanged || (patternExisted != GetSoundFile()->Patterns.IsValidPat(nPattern)))
{
updateHint.Names();
GetDocument()->UpdateAllViews(nullptr, SequenceHint(GetSoundFile()->Order.GetCurrentSequenceIndex()).Data(), nullptr);
}
if(result)
{
SetCurSel(rect);
GetDocument()->SetModified();
GetDocument()->UpdateAllViews(nullptr, updateHint, nullptr);
}
return result;
}
template<typename Func>
void CViewPattern::ApplyToSelection(Func func)
{
CSoundFile *sndFile = GetSoundFile();
if(sndFile == nullptr || !sndFile->Patterns.IsValidPat(m_nPattern))
return;
auto &pattern = sndFile->Patterns[m_nPattern];
m_Selection.Sanitize(pattern.GetNumRows(), pattern.GetNumChannels());
const CHANNELINDEX startChn = m_Selection.GetStartChannel(), endChn = m_Selection.GetEndChannel();
const ROWINDEX endRow = m_Selection.GetEndRow();
for(ROWINDEX row = m_Selection.GetStartRow(); row <= endRow; row++)
{
ModCommand *m = pattern.GetpModCommand(row, startChn);
for(CHANNELINDEX chn = startChn; chn <= endChn; chn++, m++)
{
func(*m, row, chn);
}
}
}
INT_PTR CViewPattern::OnToolHitTest(CPoint point, TOOLINFO *pTI) const
{
CRect rect;
const auto item = GetDragItem(point, rect);
const auto value = item.Value();
const CSoundFile &sndFile = *GetSoundFile();
mpt::winstring text;
switch(item.Type())
{
case DragItem::PatternHeader:
{
text = _T("Show Pattern Properties");
auto keyText = CMainFrame::GetInputHandler()->m_activeCommandSet->GetKeyTextFromCommand(kcShowPatternProperties, 0);
if(!keyText.IsEmpty())
text += MPT_CFORMAT(" ({})")(keyText);
break;
}
case DragItem::ChannelHeader:
if(value < sndFile.GetNumChannels())
{
if(!sndFile.ChnSettings[value].szName.empty())
text = MPT_TFORMAT("{}: {}")(value + 1, mpt::ToWin(sndFile.GetCharsetInternal(), sndFile.ChnSettings[value].szName));
else
text = MPT_TFORMAT("Channel {}")(value + 1);
}
break;
case DragItem::PluginName:
if(value < sndFile.GetNumChannels())
{
PLUGINDEX mixPlug = sndFile.ChnSettings[value].nMixPlugin;
if(mixPlug && mixPlug <= MAX_MIXPLUGINS)
text = MPT_TFORMAT("{}: {}")(mixPlug, mpt::ToWin(sndFile.m_MixPlugins[mixPlug - 1].GetName()));
else
text = _T("No Plugin");
}
break;
}
if(text.empty())
return CScrollView::OnToolHitTest(point, pTI);
pTI->hwnd = m_hWnd;
pTI->uId = item.ToIntPtr();
pTI->rect = rect;
// MFC will free() the text
TCHAR *textP = static_cast<TCHAR *>(calloc(text.size() + 1, sizeof(TCHAR)));
std::copy(text.begin(), text.end(), textP);
pTI->lpszText = textP;
return item.ToIntPtr();
}
// Accessible description for screen readers
HRESULT CViewPattern::get_accName(VARIANT varChild, BSTR *pszName)
{
const ModCommand &m = GetCursorCommand();
const size_t columnIndex = m_Cursor.GetColumnType();
const TCHAR *column = _T("");
static constexpr const TCHAR *regularColumns[] = {_T("Note"), _T("Instrument"), _T("Volume"), _T("Effect"), _T("Parameter")};
static constexpr const TCHAR *pcColumns[] = {_T("Note"), _T("Plugin"), _T("Plugin Parameter"), _T("Parameter Value"), _T("Parameter Value")};
static_assert(PatternCursor::lastColumn + 1 == std::size(regularColumns));
static_assert(PatternCursor::lastColumn + 1 == std::size(pcColumns));
if(m.IsPcNote() && columnIndex < std::size(pcColumns))
column = pcColumns[columnIndex];
else if(!m.IsPcNote() && columnIndex < std::size(regularColumns))
column = regularColumns[columnIndex];
const CSoundFile *sndFile = GetSoundFile();
const CHANNELINDEX chn = m_Cursor.GetChannel();
const auto channelNumber = mpt::cfmt::val(chn + 1);
CString channelName = channelNumber;
if(chn < sndFile->GetNumChannels() && !sndFile->ChnSettings[chn].szName.empty())
channelName += _T(": ") + mpt::ToCString(sndFile->GetCharsetInternal(), sndFile->ChnSettings[chn].szName);
CString str = TrackerSettings::Instance().patternAccessibilityFormat;
str.Replace(_T("%sequence%"), mpt::cfmt::val(sndFile->Order.GetCurrentSequenceIndex()));
str.Replace(_T("%order%"), mpt::cfmt::val(GetCurrentOrder()));
str.Replace(_T("%pattern%"), mpt::cfmt::val(GetCurrentPattern()));
str.Replace(_T("%row%"), mpt::cfmt::val(m_Cursor.GetRow()));
str.Replace(_T("%channel%"), channelNumber);
str.Replace(_T("%column_type%"), column);
str.Replace(_T("%column_description%"), GetCursorDescription());
str.Replace(_T("%channel_name%"), channelName);
if(str.IsEmpty())
return CModScrollView::get_accName(varChild, pszName);
*pszName = str.AllocSysString();
return S_OK;
}
OPENMPT_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink