Cool_Tools/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-24 11:24:53 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
20d28e80a5
winamp/Src/external_dependencies/openmpt-trunk/mptrack/PatternClipboard.cpp

1228 lines
34 KiB
C++
Raw Normal View History

Initial community commit
2024-09-24 14:54:57 +02:00
/*
* PatternClipboard.cpp
* --------------------
* Purpose: Implementation of the pattern clipboard mechanism
* Notes : (currently none)
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "PatternClipboard.h"
#include "PatternCursor.h"
#include "Mainfrm.h"
#include "Moddoc.h"
#include "Clipboard.h"
#include "View_pat.h"
#include "../soundlib/mod_specifications.h"
#include "../soundlib/Tables.h"
OPENMPT_NAMESPACE_BEGIN
/* Clipboard format:
* Hdr: "ModPlug Tracker S3M\r\n"
* Full: '|C#401v64A06'
* Reset: '|...........'
* Empty: '| '
* End of row: '\r\n'
*
* When pasting multiple patterns, the header line is followed by the order list:
* Orders: 0,1,2,+,-,1\r\n
* After that, the individual pattern headers and pattern data follows:
* 'Rows: 64\r\n' (must be first)
* 'Name: Pattern Name\r\n' (optional)
* 'Signature: 4/16\r\n' (optional)
* 'Swing: 16777216,16777216,16777216,16777216\r\n' (optional)
* Pattern data...
*/
PatternClipboard PatternClipboard::instance;
std::string PatternClipboard::GetFileExtension(const char *ext, bool addPadding)
{
std::string format(ext);
if(format.size() > 3)
{
format.resize(3);
}
format = mpt::ToUpperCaseAscii(format);
if(addPadding)
{
format.insert(0, 3 - format.size(), ' ');
}
return format;
}
std::string PatternClipboard::FormatClipboardHeader(const CSoundFile &sndFile)
{
return "ModPlug Tracker " + GetFileExtension(sndFile.GetModSpecifications().fileExtension, true) + "\r\n";
}
// Copy a range of patterns to both the system clipboard and the internal clipboard.
bool PatternClipboard::Copy(const CSoundFile &sndFile, ORDERINDEX first, ORDERINDEX last, bool onlyOrders)
{
const ModSequence &order = sndFile.Order();
LimitMax(first, order.GetLength());
LimitMax(last, order.GetLength());
// Set up clipboard header.
std::string data = FormatClipboardHeader(sndFile) + "Orders: ";
std::string patternData;
// Pattern => Order list assignment
std::vector<PATTERNINDEX> patList(sndFile.Patterns.Size(), PATTERNINDEX_INVALID);
PATTERNINDEX insertedPats = 0;
// Add order list and pattern information to header.
for(ORDERINDEX ord = first; ord <= last; ord++)
{
PATTERNINDEX pattern = order[ord];
if(ord != first)
data += ',';
if(pattern == order.GetInvalidPatIndex())
{
data += '-';
} else if(pattern == order.GetIgnoreIndex())
{
data += '+';
} else if(sndFile.Patterns.IsValidPat(pattern))
{
if(onlyOrders)
{
patList[pattern] = pattern;
} else if(patList[pattern] == PATTERNINDEX_INVALID)
{
// New pattern
patList[pattern] = insertedPats++;
const CPattern &pat = sndFile.Patterns[pattern];
patternData += MPT_AFORMAT("Rows: {}\r\n")(pat.GetNumRows());
std::string name = pat.GetName();
if(!name.empty())
{
patternData += "Name: " + name + "\r\n";
}
if(pat.GetOverrideSignature())
{
patternData += MPT_AFORMAT("Signature: {}/{}\r\n")(pat.GetRowsPerBeat(), pat.GetRowsPerMeasure());
}
if(pat.HasTempoSwing())
{
patternData += "Swing: ";
const TempoSwing &swing = pat.GetTempoSwing();
for(size_t i = 0; i < swing.size(); i++)
{
if(i == 0)
{
patternData += MPT_AFORMAT("{}")(swing[i]);
} else
{
patternData += MPT_AFORMAT(",{}")(swing[i]);
}
}
patternData += "\r\n";
}
patternData += CreateClipboardString(sndFile, pattern, PatternRect(PatternCursor(), PatternCursor(sndFile.Patterns[pattern].GetNumRows() - 1, sndFile.GetNumChannels() - 1, PatternCursor::lastColumn)));
}
data += mpt::afmt::val(patList[pattern]);
}
}
if(!onlyOrders)
{
data += "\r\n" + patternData;
}
if(instance.m_activeClipboard < instance.m_clipboards.size())
{
// Copy to internal clipboard
CString desc = MPT_CFORMAT("{} {} ({} to {})")(last - first + 1, onlyOrders ? CString(_T("Orders")) : CString(_T("Patterns")), first, last);
instance.m_clipboards[instance.m_activeClipboard] = {data, desc};
}
return ToSystemClipboard(data);
}
// Copy a pattern selection to both the system clipboard and the internal clipboard.
bool PatternClipboard::Copy(const CSoundFile &sndFile, PATTERNINDEX pattern, PatternRect selection)
{
std::string data = CreateClipboardString(sndFile, pattern, selection);
if(data.empty())
return false;
// Set up clipboard header
data.insert(0, FormatClipboardHeader(sndFile));
if(instance.m_activeClipboard < instance.m_clipboards.size())
{
// Copy to internal clipboard
CString desc;
desc.Format(_T("%u rows, %u channels (pattern %u)"), selection.GetNumRows(), selection.GetNumChannels(), pattern);
instance.m_clipboards[instance.m_activeClipboard] = {data, desc};
}
return ToSystemClipboard(data);
}
// Copy a pattern or pattern channel to the internal pattern or channel clipboard.
bool PatternClipboard::Copy(const CSoundFile &sndFile, PATTERNINDEX pattern, CHANNELINDEX channel)
{
if(!sndFile.Patterns.IsValidPat(pattern))
return false;
const bool patternCopy = (channel == CHANNELINDEX_INVALID);
const CPattern &pat = sndFile.Patterns[pattern];
PatternRect selection;
if(patternCopy)
selection = {PatternCursor(0, 0, PatternCursor::firstColumn), PatternCursor(pat.GetNumRows() - 1, pat.GetNumChannels() - 1, PatternCursor::lastColumn)};
else
selection = {PatternCursor(0, channel, PatternCursor::firstColumn), PatternCursor(pat.GetNumRows() - 1, channel, PatternCursor::lastColumn)};
std::string data = CreateClipboardString(sndFile, pattern, selection);
if(data.empty())
return false;
// Set up clipboard header
data.insert(0, FormatClipboardHeader(sndFile));
// Copy to internal clipboard
(patternCopy ? instance.m_patternClipboard : instance.m_channelClipboard) = {data, {}};
return true;
}
// Create the clipboard text for a pattern selection
std::string PatternClipboard::CreateClipboardString(const CSoundFile &sndFile, PATTERNINDEX pattern, PatternRect selection)
{
if(!sndFile.Patterns.IsValidPat(pattern))
return "";
if(selection.GetStartColumn() == PatternCursor::paramColumn)
{
// Special case: If selection starts with a parameter column, extend it to include the effect letter as well.
PatternCursor upper(selection.GetUpperLeft());
upper.Move(0, 0, -1);
selection = PatternRect(upper, selection.GetLowerRight());
}
const ROWINDEX startRow = selection.GetStartRow(), numRows = selection.GetNumRows();
const CHANNELINDEX startChan = selection.GetStartChannel(), numChans = selection.GetNumChannels();
std::string data;
data.reserve(numRows * (numChans * 12 + 2));
for(ROWINDEX row = 0; row < numRows; row++)
{
if(row + startRow >= sndFile.Patterns[pattern].GetNumRows())
break;
const ModCommand *m = sndFile.Patterns[pattern].GetpModCommand(row + startRow, startChan);
for(CHANNELINDEX chn = 0; chn < numChans; chn++, m++)
{
PatternCursor cursor(0, startChan + chn);
data += '|';
// Note
if(selection.ContainsHorizontal(cursor))
{
if(m->IsNote())
{
// Need to guarantee that sharps are used for the clipboard.
data += mpt::ToCharset(mpt::Charset::Locale, mpt::ustring(NoteNamesSharp[(m->note - NOTE_MIN) % 12]));
data += ('0' + (m->note - NOTE_MIN) / 12);
} else
{
data += mpt::ToCharset(mpt::Charset::Locale, sndFile.GetNoteName(m->note));
}
} else
{
// No note
data += " ";
}
// Instrument
cursor.Move(0, 0, 1);
if(selection.ContainsHorizontal(cursor))
{
if(m->instr)
{
data += ('0' + (m->instr / 10));
data += ('0' + (m->instr % 10));
} else
{
data += "..";
}
} else
{
data += " ";
}
// Volume
cursor.Move(0, 0, 1);
if(selection.ContainsHorizontal(cursor))
{
if(m->IsPcNote())
{
data += mpt::afmt::dec0<3>(m->GetValueVolCol());
}
else
{
if(m->volcmd != VOLCMD_NONE && m->vol <= 99)
{
data += sndFile.GetModSpecifications().GetVolEffectLetter(m->volcmd);
data += mpt::afmt::dec0<2>(m->vol);
} else
{
data += "...";
}
}
} else
{
data += " ";
}
// Effect
cursor.Move(0, 0, 1);
if(selection.ContainsHorizontal(cursor))
{
if(m->IsPcNote())
{
data += mpt::afmt::dec0<3>(m->GetValueEffectCol());
}
else
{
if(m->command != CMD_NONE)
{
data += sndFile.GetModSpecifications().GetEffectLetter(m->command);
} else
{
data += '.';
}
if(m->param != 0 && m->command != CMD_NONE)
{
data += mpt::afmt::HEX0<2>(m->param);
} else
{
data += "..";
}
}
} else
{
data += " ";
}
}
// Next Row
data += "\r\n";
}
return data;
}
// Try pasting a pattern selection from the system clipboard.
bool PatternClipboard::Paste(CSoundFile &sndFile, PatternEditPos &pastePos, PasteModes mode, PatternRect &pasteRect, bool &orderChanged)
{
std::string data;
if(!FromSystemClipboard(data) || !HandlePaste(sndFile, pastePos, mode, data, pasteRect, orderChanged))
{
// Fall back to internal clipboard if there's no valid pattern data in the system clipboard.
return Paste(sndFile, pastePos, mode, pasteRect, instance.m_activeClipboard, orderChanged);
}
return true;
}
// Try pasting a pattern selection from an internal clipboard.
bool PatternClipboard::Paste(CSoundFile &sndFile, PatternEditPos &pastePos, PasteModes mode, PatternRect &pasteRect, clipindex_t internalClipboard, bool &orderChanged)
{
if(internalClipboard >= instance.m_clipboards.size())
return false;
return HandlePaste(sndFile, pastePos, mode, instance.m_clipboards[internalClipboard].content, pasteRect, orderChanged);
}
// Paste from pattern or channel clipboard.
bool PatternClipboard::Paste(CSoundFile &sndFile, PATTERNINDEX pattern, CHANNELINDEX channel)
{
PatternEditPos pastePos{0, ORDERINDEX_INVALID, pattern, channel != CHANNELINDEX_INVALID ? channel : CHANNELINDEX(0)};
PatternRect pasteRect;
bool orderChanged = false;
return HandlePaste(sndFile, pastePos, pmOverwrite, (channel == CHANNELINDEX_INVALID ? instance.m_patternClipboard : instance.m_channelClipboard).content, pasteRect, orderChanged);
}
// Parse clipboard string and perform the pasting operation.
bool PatternClipboard::HandlePaste(CSoundFile &sndFile, PatternEditPos &pastePos, PasteModes mode, const std::string &data, PatternRect &pasteRect, bool &orderChanged)
{
const std::string whitespace(" \n\r\t");
PATTERNINDEX pattern = pastePos.pattern;
ORDERINDEX &curOrder = pastePos.order;
orderChanged = false;
if(sndFile.GetpModDoc() == nullptr)
return false;
CModDoc &modDoc = *(sndFile.GetpModDoc());
ModSequence &order = sndFile.Order();
bool success = false;
bool prepareUndo = true; // Prepare pattern for undo next time
bool firstUndo = true; // For chaining undos (see overflow / multi-pattern paste)
// Search for signature
std::string::size_type pos, startPos = 0;
MODTYPE pasteFormat = MOD_TYPE_NONE;
while(pasteFormat == MOD_TYPE_NONE && (startPos = data.find("ModPlug Tracker ", startPos)) != std::string::npos)
{
startPos += 16;
// Check paste format
const std::string format = mpt::ToUpperCaseAscii(mpt::trim(data.substr(startPos, 3)));
for(const auto &spec : ModSpecs::Collection)
{
if(format == GetFileExtension(spec->fileExtension, false))
{
pasteFormat = spec->internalType;
startPos += 3;
break;
}
}
}
// What is this I don't even
if(startPos == std::string::npos)
return false;
// Skip whitespaces
startPos = data.find_first_not_of(whitespace, startPos);
if(startPos == std::string::npos)
return false;
// Multi-order stuff
std::vector<PATTERNINDEX> patList;
// Multi-order mix-paste stuff
std::vector<ORDERINDEX> ordList;
std::vector<std::string::size_type> patOffset;
enum { kSinglePaste, kMultiInsert, kMultiOverwrite } patternMode = kSinglePaste;
if(data.substr(startPos, 8) == "Orders: ")
{
// Pasting several patterns at once.
patternMode = (mode == pmOverwrite) ? kMultiInsert : kMultiOverwrite;
// Put new patterns after current pattern, if it exists
if(order.IsValidPat(curOrder) && patternMode == kMultiInsert)
curOrder++;
pos = startPos + 8;
startPos = data.find('\n', pos);
ORDERINDEX writeOrder = curOrder;
const bool onlyOrders = (startPos == std::string::npos);
if(onlyOrders)
{
// Only create order list, no patterns
startPos = data.size();
} else
{
startPos++;
}
while(pos < startPos && pos != std::string::npos)
{
PATTERNINDEX insertPat;
auto curPos = pos;
// Next order item, please
pos = data.find(',', pos + 1);
if(pos != std::string::npos)
pos++;
if(data[curPos] == '+')
{
insertPat = order.GetIgnoreIndex();
} else if(data[curPos] == '-')
{
insertPat = order.GetInvalidPatIndex();
} else
{
insertPat = ConvertStrTo<PATTERNINDEX>(data.substr(curPos, 10));
if(patternMode == kMultiOverwrite)
{
// We only want the order of pasted patterns now, do not create any new patterns
ordList.push_back(insertPat);
continue;
}
if(insertPat < patList.size() && patList[insertPat] != PATTERNINDEX_INVALID)
{
// Duplicate pattern
insertPat = patList[insertPat];
} else if(!onlyOrders)
{
// New pattern
if(insertPat >= patList.size())
{
patList.resize(insertPat + 1, PATTERNINDEX_INVALID);
}
patList[insertPat] = modDoc.InsertPattern(64);
insertPat = patList[insertPat];
}
}
if((insertPat == order.GetIgnoreIndex() && !sndFile.GetModSpecifications().hasIgnoreIndex)
|| (insertPat == order.GetInvalidPatIndex() && !sndFile.GetModSpecifications().hasStopIndex)
|| insertPat == PATTERNINDEX_INVALID
|| patternMode == kMultiOverwrite)
{
continue;
}
if(order.insert(writeOrder, 1) == 0)
{
break;
}
order[writeOrder++] = insertPat;
orderChanged = true;
}
if(patternMode == kMultiInsert)
{
if(!patList.empty())
{
// First pattern we're going to paste in.
pattern = patList[0];
}
// We already modified the order list...
success = true;
pastePos.pattern = pattern;
pastePos.row = 0;
pastePos.channel = 0;
} else
{
if(ordList.empty())
return success;
// Find pattern offsets
pos = startPos;
patOffset.reserve(ordList.size());
bool patStart = false;
while((pos = data.find_first_not_of(whitespace, pos)) != std::string::npos)
{
auto eol = data.find('\n', pos + 1);
if(eol == std::string::npos)
eol = data.size();
if(data.substr(pos, 6) == "Rows: ")
{
patStart = true;
} else if(data.substr(pos, 1) == "|" && patStart)
{
patOffset.push_back(pos);
patStart = false;
}
pos = eol;
}
if(patOffset.empty())
return success;
startPos = patOffset[0];
}
}
size_t curPattern = 0; // Currently pasted pattern for multi-paste
ROWINDEX startRow = pastePos.row;
ROWINDEX curRow = startRow;
CHANNELINDEX startChan = pastePos.channel, col;
// Can we actually paste at this position?
if(!sndFile.Patterns.IsValidPat(pattern) || startRow >= sndFile.Patterns[pattern].GetNumRows() || startChan >= sndFile.GetNumChannels())
{
return success;
}
const CModSpecifications &sourceSpecs = CSoundFile::GetModSpecifications(pasteFormat);
const bool overflowPaste = (TrackerSettings::Instance().m_dwPatternSetup & PATTERN_OVERFLOWPASTE) && mode != pmPasteFlood && mode != pmPushForward && patternMode != kMultiInsert && curOrder != ORDERINDEX_INVALID;
const bool doITStyleMix = (mode == pmMixPasteIT);
const bool doMixPaste = (mode == pmMixPaste) || doITStyleMix;
const bool clipboardHasS3MCommands = (pasteFormat & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_S3M));
const bool insertNewPatterns = overflowPaste && (patternMode == kMultiOverwrite);
PatternCursor startPoint(startRow, startChan, PatternCursor::lastColumn), endPoint(startRow, startChan, PatternCursor::firstColumn);
ModCommand *patData = sndFile.Patterns[pattern].GetpModCommand(startRow, 0);
auto multiPastePos = ordList.cbegin();
pos = startPos;
while(curRow < sndFile.Patterns[pattern].GetNumRows() || overflowPaste || patternMode == kMultiInsert)
{
// Parse next line
pos = data.find_first_not_of(whitespace, pos);
if(pos == std::string::npos)
{
// End of paste
if(mode == pmPasteFlood && curRow != startRow && curRow < sndFile.Patterns[pattern].GetNumRows())
{
// Restarting pasting from beginning.
pos = startPos;
multiPastePos = ordList.cbegin();
continue;
} else
{
// Prevent infinite loop with malformed clipboard data.
break;
}
}
auto eol = data.find('\n', pos + 1);
if(eol == std::string::npos)
eol = data.size();
// Handle multi-paste: Read pattern information
if(patternMode != kSinglePaste)
{
// Parse pattern header lines
bool parsedLine = true;
if(data.substr(pos, 6) == "Rows: ")
{
pos += 6;
// Advance to next pattern
if(patternMode == kMultiOverwrite)
{
// In case of multi-pattern mix-paste, we know that we reached the end of the previous pattern and need to parse the next order now.
multiPastePos++;
if(multiPastePos == ordList.cend() || *multiPastePos >= patOffset.size())
pos = data.size();
else
pos = patOffset[*multiPastePos];
continue;
}
// Otherwise, parse this pattern header normally.
do
{
if(curPattern >= patList.size())
{
return success;
}
pattern = patList[curPattern++];
} while (pattern == PATTERNINDEX_INVALID);
ROWINDEX numRows = ConvertStrTo<ROWINDEX>(data.substr(pos, 10));
sndFile.Patterns[pattern].Resize(numRows);
patData = sndFile.Patterns[pattern].GetpModCommand(0, 0);
curRow = 0;
prepareUndo = true;
} else if(data.substr(pos, 6) == "Name: ")
{
pos += 6;
auto name = mpt::trim_right(data.substr(pos, eol - pos - 1));
sndFile.Patterns[pattern].SetName(name);
} else if(data.substr(pos, 11) == "Signature: ")
{
pos += 11;
auto pos2 = data.find("/", pos + 1);
if(pos2 != std::string::npos)
{
pos2++;
ROWINDEX rpb = ConvertStrTo<ROWINDEX>(data.substr(pos, pos2 - pos));
ROWINDEX rpm = ConvertStrTo<ROWINDEX>(data.substr(pos2, eol - pos2));
sndFile.Patterns[pattern].SetSignature(rpb, rpm);
}
} else if(data.substr(pos, 7) == "Swing: ")
{
pos += 7;
TempoSwing swing;
swing.resize(sndFile.Patterns[pattern].GetRowsPerBeat(), TempoSwing::Unity);
size_t i = 0;
while(pos != std::string::npos && pos < eol && i < swing.size())
{
swing[i++] = ConvertStrTo<TempoSwing::value_type>(data.substr(pos, eol - pos));
pos = data.find(',', pos + 1);
if(pos != std::string::npos)
pos++;
}
sndFile.Patterns[pattern].SetTempoSwing(swing);
} else
{
parsedLine = false;
}
if(parsedLine)
{
pos = eol;
continue;
}
}
if(data[pos] != '|')
{
// Not a valid line?
pos = eol;
continue;
}
if(overflowPaste)
{
// Handle overflow paste. Continue pasting in next pattern if enabled.
// If Paste Flood is enabled, this won't be called due to obvious reasons.
while(curRow >= sndFile.Patterns[pattern].GetNumRows())
{
curRow = 0;
ORDERINDEX nextOrder = order.GetNextOrderIgnoringSkips(curOrder);
if(nextOrder <= curOrder || !order.IsValidPat(nextOrder))
{
PATTERNINDEX newPat;
if(!insertNewPatterns
|| curOrder >= sndFile.GetModSpecifications().ordersMax
|| (newPat = modDoc.InsertPattern(sndFile.Patterns[pattern].GetNumRows())) == PATTERNINDEX_INVALID
|| order.insert(curOrder + 1, 1, newPat) == 0)
{
return success;
}
orderChanged = true;
nextOrder = curOrder + 1;
}
pattern = order[nextOrder];
if(!sndFile.Patterns.IsValidPat(pattern)) return success;
patData = sndFile.Patterns[pattern].GetpModCommand(0, 0);
curOrder = nextOrder;
prepareUndo = true;
startRow = 0;
}
}
success = true;
col = startChan;
// Paste columns
while((pos + 11 < data.size()) && (data[pos] == '|'))
{
pos++;
// Handle pasting large pattern into smaller pattern (e.g. 128-row pattern into MOD, which only allows 64 rows)
ModCommand dummy;
ModCommand &m = curRow < sndFile.Patterns[pattern].GetNumRows() ? patData[col] : dummy;
// Check valid paste condition. Paste will be skipped if
// - col is not a valid channelindex or
// - doing mix paste and paste destination modcommand is a PCnote or
// - doing mix paste and trying to paste PCnote on non-empty modcommand.
const bool skipPaste =
col >= sndFile.GetNumChannels() ||
(doMixPaste && m.IsPcNote()) ||
(doMixPaste && data[pos] == 'P' && !m.IsEmpty());
if(skipPaste == false)
{
// Before changing anything in this pattern, we have to create an undo point.
if(prepareUndo)
{
modDoc.GetPatternUndo().PrepareUndo(pattern, startChan, startRow, sndFile.GetNumChannels(), sndFile.Patterns[pattern].GetNumRows(), "Paste", !firstUndo);
prepareUndo = false;
firstUndo = false;
}
// ITSyle mixpaste requires that we keep a copy of the thing we are about to paste on
// so that we can refer back to check if there was anything in e.g. the note column before we pasted.
const ModCommand origModCmd = m;
// push channel data below paste point first.
if(mode == pmPushForward)
{
for(ROWINDEX pushRow = sndFile.Patterns[pattern].GetNumRows() - 1 - curRow; pushRow > 0; pushRow--)
{
patData[col + pushRow * sndFile.GetNumChannels()] = patData[col + (pushRow - 1) * sndFile.GetNumChannels()];
}
m.Clear();
}
PatternCursor::Columns firstCol = PatternCursor::lastColumn, lastCol = PatternCursor::firstColumn;
// Note
if(data[pos] != ' ' && (!doMixPaste || ((!doITStyleMix && origModCmd.note == NOTE_NONE) ||
(doITStyleMix && origModCmd.note == NOTE_NONE && origModCmd.instr == 0 && origModCmd.volcmd == VOLCMD_NONE))))
{
firstCol = PatternCursor::noteColumn;
m.note = NOTE_NONE;
if(data[pos] == '=')
m.note = NOTE_KEYOFF;
else if(data[pos] == '^')
m.note = NOTE_NOTECUT;
else if(data[pos] == '~')
m.note = NOTE_FADE;
else if(data[pos] == 'P')
{
if(data[pos + 2] == 'S' || data[pos + 2] == 's')
m.note = NOTE_PCS;
else
m.note = NOTE_PC;
} else if (data[pos] != '.')
{
// Check note names
for(uint8 i = 0; i < 12; i++)
{
if(data[pos] == NoteNamesSharp[i][0] && data[pos + 1] == NoteNamesSharp[i][1])
{
m.note = ModCommand::NOTE(i + NOTE_MIN);
break;
}
}
if(m.note != NOTE_NONE)
{
// Check octave
m.note += (data[pos + 2] - '0') * 12;
if(!m.IsNote())
{
// Invalid octave
m.note = NOTE_NONE;
}
}
}
}
// Instrument
if(data[pos + 3] > ' ' && (!doMixPaste || ( (!doITStyleMix && origModCmd.instr == 0) ||
(doITStyleMix && origModCmd.note == NOTE_NONE && origModCmd.instr == 0 && origModCmd.volcmd == VOLCMD_NONE) ) ))
{
firstCol = std::min(firstCol, PatternCursor::instrColumn);
lastCol = std::max(lastCol, PatternCursor::instrColumn);
if(data[pos + 3] >= '0' && data[pos + 3] <= ('0' + (MAX_INSTRUMENTS / 10)))
{
m.instr = (data[pos + 3] - '0') * 10 + (data[pos + 4] - '0');
} else m.instr = 0;
}
// Volume
if(data[pos + 5] > ' ' && (!doMixPaste || ((!doITStyleMix && origModCmd.volcmd == VOLCMD_NONE) ||
(doITStyleMix && origModCmd.note == NOTE_NONE && origModCmd.instr == 0 && origModCmd.volcmd == VOLCMD_NONE))))
{
firstCol = std::min(firstCol, PatternCursor::volumeColumn);
lastCol = std::max(lastCol, PatternCursor::volumeColumn);
if(data[pos + 5] != '.')
{
if(m.IsPcNote())
{
m.SetValueVolCol(ConvertStrTo<uint16>(data.substr(pos + 5, 3)));
} else
{
m.volcmd = VOLCMD_NONE;
for(int i = VOLCMD_NONE + 1; i < MAX_VOLCMDS; i++)
{
const char cmd = sourceSpecs.GetVolEffectLetter(static_cast<VolumeCommand>(i));
if(data[pos + 5] == cmd && cmd != '?')
{
m.volcmd = static_cast<VolumeCommand>(i);
break;
}
}
m.vol = (data[pos + 6] - '0') * 10 + (data[pos + 7] - '0');
}
} else
{
m.volcmd = VOLCMD_NONE;
m.vol = 0;
}
}
// Effect
if(m.IsPcNote())
{
if(data[pos + 8] != '.' && data[pos + 8] > ' ')
{
firstCol = std::min(firstCol, PatternCursor::paramColumn);
lastCol = std::max(lastCol, PatternCursor::paramColumn);
m.SetValueEffectCol(ConvertStrTo<uint16>(data.substr(pos + 8, 3)));
} else if(!origModCmd.IsPcNote())
{
// No value provided in clipboard
if((m.command == CMD_MIDI || m.command == CMD_SMOOTHMIDI) && m.param < 128)
m.SetValueEffectCol(static_cast<uint16>(Util::muldivr(m.param, ModCommand::maxColumnValue, 127)));
else
m.SetValueEffectCol(0);
}
} else
{
if(data[pos + 8] > ' ' && (!doMixPaste || ((!doITStyleMix && origModCmd.command == CMD_NONE) ||
(doITStyleMix && origModCmd.command == CMD_NONE && origModCmd.param == 0))))
{
firstCol = std::min(firstCol, PatternCursor::effectColumn);
lastCol = std::max(lastCol, PatternCursor::effectColumn);
m.command = CMD_NONE;
if(data[pos + 8] != '.')
{
for(int i = CMD_NONE + 1; i < MAX_EFFECTS; i++)
{
const char cmd = sourceSpecs.GetEffectLetter(static_cast<EffectCommand>(i));
if(data[pos + 8] == cmd && cmd != '?')
{
m.command = static_cast<EffectCommand>(i);
break;
}
}
}
}
// Effect value
if(data[pos + 9] > ' ' && (!doMixPaste || ((!doITStyleMix && (origModCmd.command == CMD_NONE || origModCmd.param == 0)) ||
(doITStyleMix && origModCmd.command == CMD_NONE && origModCmd.param == 0))))
{
firstCol = std::min(firstCol, PatternCursor::paramColumn);
lastCol = std::max(lastCol, PatternCursor::paramColumn);
m.param = 0;
if(data[pos + 9] != '.')
{
for(uint8 i = 0; i < 16; i++)
{
if(data[pos + 9] == szHexChar[i]) m.param |= (i << 4);
if(data[pos + 10] == szHexChar[i]) m.param |= i;
}
}
}
// Speed / tempo command conversion
if (sndFile.GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM))
{
switch(m.command)
{
case CMD_SPEED:
case CMD_TEMPO:
if(!clipboardHasS3MCommands)
{
if(m.param < 32)
m.command = CMD_SPEED;
else
m.command = CMD_TEMPO;
} else
{
if(m.command == CMD_SPEED && m.param >= 32)
m.param = CMD_TEMPO;
else if(m.command == CMD_TEMPO && m.param < 32)
m.param = CMD_SPEED;
}
break;
}
} else
{
switch(m.command)
{
case CMD_SPEED:
case CMD_TEMPO:
if(!clipboardHasS3MCommands)
{
if(m.param < 32)
m.command = CMD_SPEED;
else
m.command = CMD_TEMPO;
}
break;
}
}
}
// Convert some commands, if necessary. With mix paste convert only
// if the original modcommand was empty as otherwise the unchanged parts
// of the old modcommand would falsely be interpreted being of type
// origFormat and ConvertCommand could change them.
if(pasteFormat != sndFile.GetType() && (!doMixPaste || origModCmd.IsEmpty()))
m.Convert(pasteFormat, sndFile.GetType(), sndFile);
// Sanitize PC events
if(m.IsPcNote())
{
m.SetValueEffectCol(std::min(m.GetValueEffectCol(), static_cast<decltype(m.GetValueEffectCol())>(ModCommand::maxColumnValue)));
m.SetValueVolCol(std::min(m.GetValueVolCol(), static_cast<decltype(m.GetValueEffectCol())>(ModCommand::maxColumnValue)));
}
// Adjust pattern selection
if(col == startChan) startPoint.SetColumn(startChan, firstCol);
if(endPoint.CompareColumn(PatternCursor(0, col, lastCol)) < 0) endPoint.SetColumn(col, lastCol);
if(curRow > endPoint.GetRow()) endPoint.SetRow(curRow);
pasteRect = PatternRect(startPoint, endPoint);
}
pos += 11;
col++;
}
// Next row
patData += sndFile.GetNumChannels();
curRow++;
pos = eol;
}
return success;
}
// Copy one of the internal clipboards to the system clipboard.
bool PatternClipboard::SelectClipboard(clipindex_t which)
{
instance.m_activeClipboard = which;
return ToSystemClipboard(instance.m_clipboards[instance.m_activeClipboard]);
}
// Switch to the next internal clipboard.
bool PatternClipboard::CycleForward()
{
instance.m_activeClipboard++;
if(instance.m_activeClipboard >= instance.m_clipboards.size())
instance.m_activeClipboard = 0;
return SelectClipboard(instance.m_activeClipboard);
}
// Switch to the previous internal clipboard.
bool PatternClipboard::CycleBackward()
{
if(instance.m_activeClipboard == 0)
instance.m_activeClipboard = instance.m_clipboards.size() - 1;
else
instance.m_activeClipboard--;
return SelectClipboard(instance.m_activeClipboard);
}
// Set the maximum number of internal clipboards.
void PatternClipboard::SetClipboardSize(clipindex_t maxEntries)
{
instance.m_clipboards.resize(maxEntries, {"", _T("unused")});
LimitMax(instance.m_activeClipboard, maxEntries - 1);
}
// Check whether patterns can be pasted from clipboard
bool PatternClipboard::CanPaste()
{
return !!IsClipboardFormatAvailable(CF_TEXT);
}
// System-specific clipboard functions
bool PatternClipboard::ToSystemClipboard(const std::string_view &data)
{
Clipboard clipboard(CF_TEXT, data.size() + 1);
if(auto dst = clipboard.As<char>())
{
std::copy(data.begin(), data.end(), dst);
dst[data.size()] = '\0';
return true;
}
return false;
}
// System-specific clipboard functions
bool PatternClipboard::FromSystemClipboard(std::string &data)
{
Clipboard clipboard(CF_TEXT);
if(auto cbdata = clipboard.Get(); cbdata.data())
{
if(cbdata.size() > 0)
data.assign(mpt::byte_cast<char *>(cbdata.data()), cbdata.size() - 1);
return !data.empty();
}
return false;
}
BEGIN_MESSAGE_MAP(PatternClipboardDialog, ResizableDialog)
ON_EN_UPDATE(IDC_EDIT1, &PatternClipboardDialog::OnNumClipboardsChanged)
ON_LBN_SELCHANGE(IDC_LIST1, &PatternClipboardDialog::OnSelectClipboard)
ON_LBN_DBLCLK(IDC_LIST1, &PatternClipboardDialog::OnEditName)
END_MESSAGE_MAP()
PatternClipboardDialog PatternClipboardDialog::instance;
void PatternClipboardDialog::DoDataExchange(CDataExchange *pDX)
{
DDX_Control(pDX, IDC_SPIN1, m_numClipboardsSpin);
DDX_Control(pDX, IDC_LIST1, m_clipList);
}
PatternClipboardDialog::PatternClipboardDialog() : m_editNameBox(*this)
{
}
void PatternClipboardDialog::Show()
{
instance.m_isLocked = true;
if(!instance.m_isCreated)
{
instance.Create(IDD_CLIPBOARD, CMainFrame::GetMainFrame());
instance.m_numClipboardsSpin.SetRange(0, int16_max);
}
instance.SetDlgItemInt(IDC_EDIT1, mpt::saturate_cast<UINT>(PatternClipboard::GetClipboardSize()), FALSE);
instance.m_isLocked = false;
instance.m_isCreated = true;
instance.UpdateList();
instance.SetWindowPos(nullptr, instance.m_posX, instance.m_posY, 0, 0, SWP_SHOWWINDOW | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER | (instance.m_posX == -1 ? SWP_NOMOVE : 0));
}
void PatternClipboardDialog::OnNumClipboardsChanged()
{
if(m_isLocked)
{
return;
}
OnEndEdit();
PatternClipboard::SetClipboardSize(GetDlgItemInt(IDC_EDIT1, nullptr, FALSE));
UpdateList();
}
void PatternClipboardDialog::UpdateList()
{
if(instance.m_isLocked)
{
return;
}
instance.m_clipList.ResetContent();
PatternClipboard::clipindex_t i = 0;
for(const auto &clip : PatternClipboard::instance.m_clipboards)
{
const int item = instance.m_clipList.AddString(clip.description);
instance.m_clipList.SetItemDataPtr(item, reinterpret_cast<void *>(i));
if(PatternClipboard::instance.m_activeClipboard == i)
{
instance.m_clipList.SetCurSel(item);
}
i++;
}
}
void PatternClipboardDialog::OnSelectClipboard()
{
if(m_isLocked)
{
return;
}
PatternClipboard::clipindex_t item = reinterpret_cast<PatternClipboard::clipindex_t>(m_clipList.GetItemDataPtr(m_clipList.GetCurSel()));
PatternClipboard::SelectClipboard(item);
OnEndEdit();
}
void PatternClipboardDialog::OnOK()
{
const CWnd *focus = GetFocus();
if(focus == &m_editNameBox)
{
// User pressed enter in clipboard name edit box => cancel editing
OnEndEdit();
} else if(focus == &m_clipList)
{
// User pressed enter in the clipboard name list => start editing
OnEditName();
} else
{
ResizableDialog::OnOK();
}
}
void PatternClipboardDialog::OnCancel()
{
if(GetFocus() == &m_editNameBox)
{
// User pressed enter in clipboard name edit box => just cancel editing
m_editNameBox.DestroyWindow();
return;
}
OnEndEdit(false);
m_isCreated = false;
m_isLocked = true;
RECT rect;
GetWindowRect(&rect);
m_posX = rect.left;
m_posY = rect.top;
DestroyWindow();
}
void PatternClipboardDialog::OnEditName()
{
OnEndEdit();
const int sel = m_clipList.GetCurSel();
if(sel == LB_ERR)
{
return;
}
CRect rect;
m_clipList.GetItemRect(sel, rect);
rect.InflateRect(0, 2, 0, 2);
// Create the edit control
m_editNameBox.Create(WS_VISIBLE | WS_CHILD | WS_BORDER | ES_LEFT | ES_AUTOHSCROLL, rect, &m_clipList, 1);
m_editNameBox.SetFont(m_clipList.GetFont());
m_editNameBox.SetWindowText(PatternClipboard::instance.m_clipboards[sel].description);
m_editNameBox.SetSel(0, -1, TRUE);
m_editNameBox.SetFocus();
SetWindowLongPtr(m_editNameBox.m_hWnd, GWLP_USERDATA, (LONG_PTR)m_clipList.GetItemDataPtr(sel));
}
void PatternClipboardDialog::OnEndEdit(bool apply)
{
if(m_editNameBox.GetSafeHwnd() == NULL)
{
return;
}
if(apply)
{
size_t sel = GetWindowLongPtr(m_editNameBox.m_hWnd, GWLP_USERDATA);
if(sel >= PatternClipboard::instance.m_clipboards.size())
{
// What happened?
return;
}
CString newName;
m_editNameBox.GetWindowText(newName);
PatternClipboard::instance.m_clipboards[sel].description = newName;
}
SetWindowLongPtr(m_editNameBox.m_hWnd, GWLP_USERDATA, LONG_PTR(-1));
m_editNameBox.DestroyWindow();
UpdateList();
}
BEGIN_MESSAGE_MAP(PatternClipboardDialog::CInlineEdit, CEdit)
ON_WM_KILLFOCUS()
END_MESSAGE_MAP()
PatternClipboardDialog::CInlineEdit::CInlineEdit(PatternClipboardDialog &dlg) : parent(dlg)
{
}
void PatternClipboardDialog::CInlineEdit::OnKillFocus(CWnd *newWnd)
{
parent.OnEndEdit(true);
CEdit::OnKillFocus(newWnd);
}
OPENMPT_NAMESPACE_END
Reference in New Issue Copy Permalink