public void ChangeSetListSlotNotTooMany()
{
IPcgMemory pcg = CreatePcg();
IProgram programIa000 = (IProgram)pcg.ProgramBanks[0][0];
ISetListSlot setListSlot000000 = (ISetListSlot)(pcg.SetLists[0])[0];
setListSlot000000.SelectedPatchType = SetListSlot.PatchType.Program;
setListSlot000000.UsedPatch = programIa000;
IProgram programIa001 = (IProgram)pcg.ProgramBanks[0][1];
ISetListSlot setListSlot000001 = (ISetListSlot)(pcg.SetLists[0])[1];
setListSlot000001.SelectedPatchType = SetListSlot.PatchType.Program;
setListSlot000001.UsedPatch = programIa001;
ReferenceChanger referenceChanger = new ReferenceChanger(pcg);
RuleParser ruleParser = new RuleParser(pcg);
referenceChanger.ParseRules(ruleParser, "I-A000->I-B000");
referenceChanger.ChangeReferences();
Debug.Assert(setListSlot000000.UsedPatch == pcg.ProgramBanks[1][0]); // Changed
Debug.Assert(setListSlot000001.UsedPatch == programIa001); // Not changed
}
/// <summary>
///
/// </summary>
public override void Clear()
{
IPcgMemory memory = (IPcgMemory)Root;
if (memory.AssignedClearProgram == null)
{
UsedProgram = (IProgram)(PcgRoot.ProgramBanks[0][0]);
}
else
{
UsedProgram = memory.AssignedClearProgram;
}
GetParam(ParameterNames.TimbreParameterName.Status).Value = "Off";
if (GetParam(ParameterNames.TimbreParameterName.Mute) != null)
{
GetParam(ParameterNames.TimbreParameterName.Mute).Value = true;
}
GetParam(ParameterNames.TimbreParameterName.Volume).Value = 0;
GetParam(ParameterNames.TimbreParameterName.MidiChannel).Value = 15;
GetParam(ParameterNames.TimbreParameterName.BottomKey).Value = 0;
GetParam(ParameterNames.TimbreParameterName.TopKey).Value = 0;
GetParam(ParameterNames.TimbreParameterName.BottomVelocity).Value = 0;
GetParam(ParameterNames.TimbreParameterName.TopVelocity).Value = 0;
GetParam(ParameterNames.TimbreParameterName.OscMode).Value = "Force Poly";
GetParam(ParameterNames.TimbreParameterName.OscSelect).Value = "Hide OSC2";
GetParam(ParameterNames.TimbreParameterName.Transpose).Value = 0;
GetParam(ParameterNames.TimbreParameterName.BendRange).Value = 0;
RefillColumns();
}
/// <summary>
/// Cut or Copy for cut/copy/paste.
/// </summary>
/// <param name="pcgClipBoard"></param>
/// <param name="setListsSelected"></param>
/// <param name="waveSequenceBanksSelected"></param>
/// <param name="allPatchesSelected"></param>
/// <param name="banks"></param>
/// <param name="patches"></param>
/// <param name="cutPasteAction">Cut paste action selected; clears patches after copying (otherwise it is a
/// cut/copy/paste action)</param>
/// <param name="selectedPcgMemory"></param>
/// <param name="selectedScopeSet"></param>
/// <param name="programBanksSelected"></param>
/// <param name="combiBanksSelected"></param>
/// <param name="drumKitBanksSelected"></param>
/// /// <param name="drumPatternBanksSelected"></param>
public void CopyPasteCopy(IPcgClipBoard pcgClipBoard, IPcgMemory selectedPcgMemory, PcgViewModel.ScopeSet selectedScopeSet,
bool programBanksSelected, bool combiBanksSelected, bool setListsSelected, bool drumKitBanksSelected,
bool drumPatternBanksSelected, bool waveSequenceBanksSelected,
bool allPatchesSelected,
ObservableCollectionEx <IBank> banks, ObservableCollectionEx <IPatch> patches, bool cutPasteAction)
{
PcgClipBoard = pcgClipBoard;
SelectedPcgMemory = selectedPcgMemory;
SelectedScopeSet = selectedScopeSet;
ProgramBanksSelected = programBanksSelected;
CombiBanksSelected = combiBanksSelected;
SetListsSelected = setListsSelected;
DrumKitBanksSelected = drumKitBanksSelected;
DrumPatternBanksSelected = drumPatternBanksSelected;
WaveSequenceBanksSelected = waveSequenceBanksSelected;
AllPatchesSelected = allPatchesSelected;
Banks = banks;
Patches = patches;
CopyPasteInit(cutPasteAction);
CopyPasteCopyPatches(cutPasteAction);
PcgClipBoard.Memorize();
}
public void ChangeCombi()
{
IPcgMemory pcg = CreatePcg();
IProgram programIa000 = (IProgram)pcg.ProgramBanks[0][0];
ICombi combiIa000 = (ICombi)(pcg.CombiBanks[0])[0];
combiIa000.Name = "NonEmpty";
combiIa000.Timbres.TimbresCollection[0].UsedProgram = programIa000;
// Set most virtual banks loaded to save time.
foreach (IBank bank in pcg.CombiBanks.BankCollection.Where(
bank => (bank.Type == BankType.EType.Virtual) && (bank.Id != "V-0A")))
{
bank.IsLoaded = false;
}
// Run actual test.
ReferenceChanger referenceChanger = new ReferenceChanger(pcg);
RuleParser ruleParser = new RuleParser(pcg);
referenceChanger.ParseRules(ruleParser, "I-A000->I-B000");
referenceChanger.ChangeReferences();
Debug.Assert(combiIa000.Timbres.TimbresCollection[0].UsedProgram == pcg.ProgramBanks[1][0]);
}
/// <summary>
///
/// </summary>
/// <param name="pcgClipBoard"></param>
/// <param name="selectedPcgMemory"></param>
/// <param name="selectedScopeSet"></param>
/// <param name="programBanksSelected"></param>
/// <param name="combiBanksSelected"></param>
/// <param name="setListsSelected"></param>
/// <param name="waveSequenceBanksSelected"></param>
/// <param name="allPatchesSelected"></param>
/// <param name="banks"></param>
/// <param name="patches"></param>
/// <param name="drumKitsSelected"></param>
/// <param name="drumPatternsSelected"></param>
/// <returns></returns>
public string CopyPastePaste(IPcgClipBoard pcgClipBoard, IPcgMemory selectedPcgMemory, PcgViewModel.ScopeSet selectedScopeSet,
bool programBanksSelected, bool combiBanksSelected, bool setListsSelected, bool drumKitsSelected,
bool drumPatternsSelected, bool waveSequenceBanksSelected,
bool allPatchesSelected,
ObservableCollectionEx <IBank> banks, ObservableCollectionEx <IPatch> patches)
{
PcgClipBoard = pcgClipBoard;
SelectedPcgMemory = selectedPcgMemory;
SelectedScopeSet = selectedScopeSet;
ProgramBanksSelected = programBanksSelected;
CombiBanksSelected = combiBanksSelected;
SetListsSelected = setListsSelected;
DrumKitBanksSelected = drumKitsSelected;
DrumPatternBanksSelected = drumPatternsSelected;
WaveSequenceBanksSelected = waveSequenceBanksSelected;
AllPatchesSelected = allPatchesSelected;
Banks = banks;
Patches = patches;
PasteDuplicates();
var infoText = PastePatches();
if (!PcgClipBoard.CutPasteSelected)
{
PcgClipBoard.FixPasteReferencesAfterCopyPaste();
}
if (PcgClipBoard.IsPastingFinished)
{
PastingFinished();
}
return(infoText);
}
/// <summary>
///
/// </summary>
/// <param name="currentPcgMemory"></param>
/// <param name="content"></param>
/// <param name="contentType"></param>
/// <param name="sysExStartOffset"></param>
/// <param name="sysExEndOffset"></param>
public Z1FileReader(
IPcgMemory currentPcgMemory, byte[] content, PcgMemory.ContentType contentType,
int sysExStartOffset, int sysExEndOffset)
: base(currentPcgMemory, content, contentType, sysExStartOffset, sysExEndOffset)
{
//TimbreByteSize = 16;
}
public static void SetChars(IPcgMemory pcgMemory, byte[] data, int start, int maxLength, string text)
{
Debug.Assert(pcgMemory != null);
Debug.Assert(data != null);
Debug.Assert(start >= 4); // Do not overwrite KORG header.
Debug.Assert(text.Length <= maxLength);
var dirty = false;
int index;
for (index = 0; index < text.Length; index++)
{
var orgData = data[start + index];
data[start + index] = (byte)(text[index]);
//Console.WriteLine(String.Format("SetChars: Write {0} to {1} ", (byte) (text[index]), start + index));
dirty |= (orgData != data[start + index]);
}
// Padd with zeros.
while (index < maxLength)
{
dirty |= (data[start + index] != 0);
data[start + index] = 0;
index++;
}
pcgMemory.IsDirty |= dirty;
}
/// <summary>
///
/// </summary>
/// <param name="currentPcgMemory"></param>
/// <param name="content"></param>
/// <param name="contentType"></param>
/// <param name="sysExStartOffset"></param>
/// <param name="sysExEndOffset"></param>
protected SysExFileReader(IPcgMemory currentPcgMemory, byte[] content,
PcgMemory.ContentType contentType, int sysExStartOffset, int sysExEndOffset)
: base(currentPcgMemory, content)
{
ContentType = contentType;
SysExStartOffset = sysExStartOffset;
SysExEndOffset = sysExEndOffset;
}
/// <summary>
///
/// </summary>
/// <param name="memory"></param>
public ProgramReferenceChangerWindow(IPcgMemory memory)
{
_memory = memory;
InitializeComponent();
LabelProgress.Visibility = Visibility.Hidden;
ProgressBarRules.Visibility = Visibility.Hidden;
}
public void NoRules()
{
IPcgMemory pcg = CreatePcg();
RuleParser ruleParser = new RuleParser(pcg);
ruleParser.Parse("");
Debug.Assert(ruleParser.HasParsedOk);
Debug.Assert(ruleParser.ParsedRules.Count == 0);
}
/// <summary>
/// Changes all references of the original location of patch to program.
/// Only used for cut/paste.
/// </summary>
/// <param name="patch"></param>
/// <param name="program"></param>
private static void FixReferencesToProgram(IClipBoardPatch patch, IProgram program)
{
IPcgMemory memory = patch.OriginalLocation.Root as IPcgMemory;
Debug.Assert(memory != null);
FixProgramReferencesToCombi(patch, program, memory);
FixProgramReferencesToSetLists(patch, program, memory);
}
/// <summary>
///
/// </summary>
/// <param name="memory"></param>
/// <param name="offset"></param>
private void ReadAllCombis(IPcgMemory memory, int offset)
{
_bank = 0;
_patchIndex = 0;
foreach (IBank bank in memory.CombiBanks.BankCollection)
{
ReadSingleCombi(offset);
offset += bank.ByteLength;
}
}
public void BankRule()
{
IPcgMemory pcg = CreatePcg();
RuleParser ruleParser = new RuleParser(pcg);
ruleParser.Parse("I-A->I-B");
Debug.Assert(ruleParser.HasParsedOk);
Debug.Assert(ruleParser.ParsedRules.Count == pcg.ProgramBanks[0].CountPatches);
PcgTools.Model.Common.Synth.Meta.IPatch rule = ruleParser.ParsedRules[pcg.ProgramBanks[0][127]]; // I-A127
Debug.Assert(rule == pcg.ProgramBanks[1][127]); // I-B127
}
public void RangeRule()
{
IPcgMemory pcg = CreatePcg();
RuleParser ruleParser = new RuleParser(pcg);
ruleParser.Parse("I-A000..010->I-B000..010");
Debug.Assert(ruleParser.HasParsedOk);
Debug.Assert(ruleParser.ParsedRules.Count == 11);
PcgTools.Model.Common.Synth.Meta.IPatch rule = ruleParser.ParsedRules[pcg.ProgramBanks[0][10]]; // I-A010
Debug.Assert(rule == pcg.ProgramBanks[1][10]); // I-B010
}
/// <summary>
///
/// </summary>
/// <param name="memory"></param>
/// <param name="offset"></param>
private void ReadAllPrograms(IPcgMemory memory, int offset)
{
_bank = 0;
_patchIndex = 0;
foreach (IBank bank in memory.ProgramBanks.BankCollection.Where(
bank => bank.Type != BankType.EType.Gm))
{
ReadSingleProgram(offset);
offset += bank.ByteLength;
}
}
/// <summary>
///
/// </summary>
/// <param name="changes"></param>
/// <param name="pcgMemory">PCG Memory of changes</param>
public void ChangeTimbreReferences(Dictionary <IProgram, IProgram> changes, IPcgMemory pcgMemory)
{
foreach (ITimbre timbre in from bank in BankCollection
where bank.IsFilled
from combi in bank.Patches
from timbre in ((Combi)combi).Timbres.TimbresCollection
where (!timbre.UsedProgram.IsFromMasterFile || timbre.UsedProgram.PcgRoot == pcgMemory) &&
changes.ContainsKey(timbre.UsedProgram)
select timbre)
{
timbre.UsedProgram = changes[timbre.UsedProgram];
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void OnPcgViewModelPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "SelectedMemory")
{
IPcgMemory memory = ((PcgViewModel)sender).SelectedPcgMemory;
if (memory != null)
{
memory.PropertyChanged += OnSelectedPcgMemoryPropertyChanged;
}
Instances.UpdateStates();
}
}
/// <summary>
///
/// </summary>
/// <param name="currentPcgMemory"></param>
/// <param name="content"></param>
public TritonKarmaPcgFileReader(IPcgMemory currentPcgMemory, byte[] content)
: base(currentPcgMemory, content)
{
// PcgFileHeader PcgFileHeader;
// Pcg1Chunk Pcg1Chunk;
// Div1Chunk Div1Chunk;
// Ini2Chunk Ini2Chunk;
// Ini1Chunk Ini1Chunk;
// Prg1Chunk Prg1Chunk;
// Cmb1Chunk Cmb1Chunk;
// Dkt1Chunk Dkt1Chunk;
// Arp1Chunk Arp1Chunk;
// Glb1Chunk Glb1Chunk;
}
/// <summary>
///
/// </summary>
/// <param name="pcgMemory"></param>
/// <param name="content"></param>
/// <returns></returns>
public override IPatchesFileReader CreateFileReader(IPcgMemory pcgMemory, byte[] content)
{
PatchesFileReader reader;
if (Util.GetChars(content, 0, 2) == "tr")
{
reader = new Kross2TrFileReader(pcgMemory, content, _contentType);
}
else
{
reader = new Kross2PcgFileReader(pcgMemory, content);
}
return(reader);
}
/// <summary>
///
/// </summary>
/// <param name="currentPcgMemory"></param>
/// <param name="content"></param>
/// <param name="modeChangeOffset"></param>
public M50PcgFileReader(IPcgMemory currentPcgMemory, byte[] content, int modeChangeOffset = 0)
: base(currentPcgMemory, content)
{
// PcgFileHeader PcgFileHeader;
// Pcg1Chunk Pcg1Chunk;
// Div1Chunk Div1Chunk;
// Ini2Chunk Ini2Chunk;
// Ini1Chunk Ini1Chunk;
// Prg1Chunk Prg1Chunk;
// Cmb1Chunk Cmb1Chunk;
// Dkt1Chunk Dkt1Chunk;
// Arp1Chunk Arp1Chunk;
// Glb1Chunk Glb1Chunk;
}
/// <summary>
///
/// </summary>
/// <param name="currentPcgMemory"></param>
/// <param name="content"></param>
protected KronosOasysPcgFileReader(IPcgMemory currentPcgMemory, byte[] content)
: base(currentPcgMemory, content)
{
// PcgFileHeader PcgFileHeader;
// Pcg1Chunk Pcg1Chunk;
// Div1Chunk Div1Chunk;
// Ini2Chunk Ini2Chunk;
// Ini1Chunk Ini1Chunk;
// Sls1Chunk Sls1Chunk;
// Prg1Chunk Prg1Chunk;
// Cmb1Chunk Cmb1Chunk;
// Dkt1Chunk Dkt1Chunk;
// Arp1Chunk Arp1Chunk;
// Glb1Chunk Glb1Chunk;
}
/// <summary>
/// Returns the global of this PCG or if no global present, the Master PCG file's global.
/// This is a copy from Timbre.cs
/// </summary>
/// <returns></returns>
protected IGlobal FindGlobal()
{
IGlobal global = (PcgRoot.Content == null) ? null : PcgRoot.Global;
if (global == null)
{
// Find master PCG memory (except when file is master file itself).
IPcgMemory masterPcgMemory = MasterFiles.MasterFiles.Instances.FindMasterPcg(Root.Model);
if ((masterPcgMemory != null) && (masterPcgMemory.FileName != Root.FileName))
{
global = masterPcgMemory.Global;
}
}
return(global);
}
public static void SetInt(IPcgMemory pcgMemory, byte[] data, int start, int amount, int value)
{
Debug.Assert(pcgMemory != null);
Debug.Assert(data != null);
var dirty = false;
switch (amount)
{
case 1:
Debug.Assert((value >= 0) && (value <= 255));
dirty |= (data[start] != (byte)value);
//Console.WriteLine(String.Format("SetInt: Write {0} to {1} ", (byte) value, start));
data[start] = (byte)value;
break;
case 2:
Debug.Assert((value >= 0) && (value <= 65535));
dirty |= (data[start] != (byte)(value / 256));
//Console.WriteLine(String.Format("SetInt: Write two bytes to {0}", start));
data[start] = (byte)(value / 256);
dirty |= (data[start + 1] != (byte)(value % 256));
data[start + 1] = (byte)(value % 256);
break;
case 4:
//Console.WriteLine(String.Format("SetInt: Write four bytes to {0}", start));
dirty |= (data[start + 3] != (byte)(value % 256));
data[start + 3] = (byte)(value % 256);
value /= 256;
dirty |= (data[start + 2] != (byte)(value % 256));
data[start + 2] = (byte)(value % 256);
value /= 256;
dirty |= (data[start + 1] != (byte)(value % 256));
data[start + 1] = (byte)(value % 256);
dirty |= (data[start] != (byte)(value / 256));
data[start] = (byte)(value / 256);
break;
default:
throw new ApplicationException("Illegal value");
}
pcgMemory.IsDirty |= dirty;
}
/// <summary>
/// In case the name changes, check if it is a single patch file and if so, the name of the file might need to be changed.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case "Name":
IPcgMemory memory = PcgRoot;
if ((memory.HasOnlyOnePatch && Settings.Default.Edit_RenameFileWhenPatchNameChanges))
{
string directoryName = Path.GetDirectoryName(memory.OriginalFileName);
PcgRoot.FileName = directoryName + memory.NameOfOnlyPatch;
}
break;
// default: Do nothing
}
}
/// <summary>
///
/// </summary>
/// <param name="currentPcgMemory"></param>
/// <param name="content"></param>
public MicroStationPcgFileReader(IPcgMemory currentPcgMemory, byte[] content)
: base(currentPcgMemory, content)
{
// PcgFileHeader PcgFileHeader;
// Pcg1Chunk Pcg1Chunk;
// Div1Chunk Div1Chunk;
// Ini2Chunk Ini2Chunk;
// Ini1Chunk Ini1Chunk;
// Prg1Chunk Prg1Chunk;
// Cmb1Chunk Cmb1Chunk;
// Dkt1Chunk Dkt1Chunk;
// Arp1Chunk Arp1Chunk;
// Glb1Chunk Glb1Chunk;
currentPcgMemory.PcgChecksumType = PcgMemory.ChecksumType.MicroStation;
}
public void TwoRules()
{
IPcgMemory pcg = CreatePcg();
pcg.Content = new byte[10000];
RuleParser ruleParser = new RuleParser(pcg);
ruleParser.Parse("I-A000->I-B000\nI-A001->I-B001");
Debug.Assert(ruleParser.HasParsedOk);
Debug.Assert(ruleParser.ParsedRules.Count == 2);
PcgTools.Model.Common.Synth.Meta.IPatch rule = ruleParser.ParsedRules[pcg.ProgramBanks[0][0]]; // I-A000
Debug.Assert(rule == pcg.ProgramBanks[1][0]); // I-B000
rule = ruleParser.ParsedRules[pcg.ProgramBanks[0][1]]; // I-A001
Debug.Assert(rule == pcg.ProgramBanks[1][1]); // I-B001
}
/// <summary>
///
/// </summary>
/// <param name="currentPcgMemory"></param>
/// <param name="content"></param>
public NautilusPcgFileReader(IPcgMemory currentPcgMemory, byte[] content)
: base(currentPcgMemory, content)
{
// PcgFileHeader PcgFileHeader;
// Pcg1Chunk Pcg1Chunk;
// Div1Chunk Div1Chunk;
// Ini2Chunk Ini2Chunk;
// Ini1Chunk Ini1Chunk;
// Sls1Chunk Sls1Chunk;
// Prg1Chunk Prg1Chunk;
// Cmb1Chunk Cmb1Chunk;
// Dkt1Chunk Dkt1Chunk;
// Arp1Chunk Arp1Chunk;
// Glb1Chunk Glb1Chunk;
currentPcgMemory.Model = Models.Find(Models.EOsVersion.Nautilus);
}
/// <summary>
///
/// </summary>
/// <param name="currentPcgMemory"></param>
/// <param name="content"></param>
/// <param name="modeChangeOffset"></param>
public Kross2PcgFileReader(IPcgMemory currentPcgMemory, byte[] content, int modeChangeOffset = 0)
: base(currentPcgMemory, content)
{
// PcgFileHeader PcgFileHeader;
// Pcg1Chunk Pcg1Chunk;
// Div1Chunk Div1Chunk;
// Ini2Chunk Ini2Chunk;
// Ini1Chunk Ini1Chunk;
// Prg1Chunk Prg1Chunk;
// Cmb1Chunk Cmb1Chunk;
// Dkt1Chunk Dkt1Chunk;
// Arp1Chunk Arp1Chunk;
// Glb1Chunk Glb1Chunk;
if (content[9] == 1)
{
currentPcgMemory.PcgChecksumType = PcgMemory.ChecksumType.Kross2;
}
}
/// <summary>
///
/// </summary>
/// <param name="pcgMemory"></param>
/// <param name="content"></param>
/// <returns></returns>
public override IPatchesFileReader CreateFileReader(IPcgMemory pcgMemory, byte[] content)
{
IPatchesFileReader reader = null;
switch (_fileType)
{
case Memory.FileType.MkxlPAll:
reader = new MicroKorgXlMkxlPAllFileReader(pcgMemory, content);
break;
case Memory.FileType.MkxlPProg:
reader = new MicroKorgXlMkxlPProgFileReader(pcgMemory, content);
break;
default:
throw new NotSupportedException("Unsupported reader");
}
return(reader);
}
/// <summary>
/// Changes all references of the original location of patch to combi.
/// Only used for cut/paste.
/// </summary>
/// <param name="patch"></param>
/// <param name="combi"></param>
private static void FixReferencesToCombi(IClipBoardPatch patch, ICombi combi)
{
IPcgMemory memory = patch.OriginalLocation.Root as IPcgMemory;
Debug.Assert(memory != null);
// Change set list slots (if present and not from master file).
if (memory.SetLists != null)
{
foreach (ISetListSlot slot in memory.SetLists.BankCollection.Where(
bank => bank.IsWritable && !bank.IsFromMasterFile).SelectMany(
list => list.Patches, (list, patch1) => (ISetListSlot)patch1).Where(
slot => (slot.SelectedPatchType == SetListSlot.PatchType.Combi) &&
(slot.UsedPatch == patch.OriginalLocation)))
{
slot.UsedPatch = combi;
}
}
}
