/// <summary> /// Copies combi and set list slot. /// </summary> /// <param name="setListTarget"></param> /// <param name="combiBankTarget"></param> /// <param name="mainMidiChannel"></param> /// <param name="secondaryMidiChannel"></param> /// <param name="sourceSetListSlot"></param> /// <param name="currentTargetCombiIndex"></param> /// <param name="finishedPrematurely"></param> /// <param name="currentTargetSetListSlotIndex"></param> /// <returns></returns> private static bool CopySecondaryPatches(ISetList setListTarget, ICombiBank combiBankTarget, int mainMidiChannel, int secondaryMidiChannel, ISetListSlot sourceSetListSlot, ref int currentTargetCombiIndex, ref bool finishedPrematurely, ref int currentTargetSetListSlotIndex) { ICombi sourceCombi = (ICombi)sourceSetListSlot.UsedPatch; if (sourceCombi.UsesMidiChannel(secondaryMidiChannel)) { // Create second combi with changed name and MIDI channels switched. if (currentTargetCombiIndex >= combiBankTarget.CountPatches) { finishedPrematurely = true; return(true); } sourceCombi.PcgRoot.CopyPatch(sourceCombi, combiBankTarget.Patches[currentTargetCombiIndex]); ICombi combi = (ICombi)combiBankTarget.Patches[currentTargetCombiIndex]; combi.SetNameSuffix($"/MC{secondaryMidiChannel}"); combi.SwitchMidiChannels(mainMidiChannel, secondaryMidiChannel); currentTargetCombiIndex++; // Copy set list slot with changed name and referencing to combi. if (currentTargetSetListSlotIndex >= setListTarget.Patches.Count) { finishedPrematurely = true; return(true); } sourceSetListSlot.PcgRoot.CopyPatch(sourceSetListSlot, setListTarget.Patches[currentTargetSetListSlotIndex]); ISetListSlot setListSlotSecondary = (ISetListSlot)setListTarget.Patches[currentTargetSetListSlotIndex]; setListSlotSecondary.SetNameSuffix($"/MC{secondaryMidiChannel}"); setListSlotSecondary.UsedPatch = combi; currentTargetSetListSlotIndex++; } return(false); }
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> /// <param name="setListSlot"></param> public ClipBoardSetListSlot(ISetListSlot setListSlot) : base(setListSlot.PcgRoot.Content, setListSlot.ByteOffset, setListSlot.ByteLength) { OriginalLocation = setListSlot; if ((setListSlot.Root is KronosPcgMemory memory) && (memory.PcgRoot.Model.OsVersion == Models.EOsVersion.Kronos15_16)) { KronosOs1516Bank = Util.GetInt(memory.Content, ((KronosSetListSlot)setListSlot).Stl2BankOffset, 1); KronosOs1516Patch = Util.GetInt(memory.Content, ((KronosSetListSlot)setListSlot).Stl2PatchOffset, 1); } }
/// <summary> /// /// </summary> /// <param name="rule"></param> private void ChangeReferencesInSetListSlots(KeyValuePair <IPatch, IPatch> rule) { foreach (IBank setList in _memory.SetLists.BankCollection.Where(setList => setList.IsFilled)) { for (int index = 0; index < setList.Patches.Count; index++) { ISetListSlot setListSlot = (ISetListSlot)setList[index]; if ((setListSlot.SelectedPatchType == SetListSlot.PatchType.Program) && (setListSlot.UsedPatch == rule.Key) && !_processedSetListSlots.Contains(setListSlot)) { setListSlot.UsedPatch = rule.Value; _processedSetListSlots.Add(setListSlot); } } } }
/// <summary> /// /// </summary> /// <param name="setListSlot"></param> /// <param name="clearAfterCopy"></param> public void CopySetListSlotToClipBoard(ISetListSlot setListSlot, bool clearAfterCopy) { // Copy set list slot. if (setListSlot.PcgRoot.Content != null) { var clipBoardSetListSlot = new ClipBoardSetListSlot(setListSlot); SetListSlots.CopiedPatches.Add(clipBoardSetListSlot); if (clearAfterCopy) { setListSlot.Clear(); } // Copy program of combi (do not copy song). if (!CutPasteSelected) { var usedPatch = setListSlot.UsedPatch; if ((usedPatch != null) && (Settings.Default.CopyPaste_CopyPatchesFromMasterFile || !usedPatch.IsFromMasterFile)) { if (setListSlot.UsedPatch is IProgram) { var program = (IProgram)usedPatch; if (((IProgramBank)(program.Parent)).Type != BankType.EType.Gm) { clipBoardSetListSlot.Reference = CopyProgramToClipBoard(program, false); } } else if (setListSlot.UsedPatch is ICombi) { var combi = (ICombi)usedPatch; clipBoardSetListSlot.Reference = CopyCombiToClipBoard(combi, false); } } } } }
/* * /// <summary> * /// Fix drum kit references in programs (clipBoardPatches). * /// </summary> * /// <param name="clipBoardPatches"></param> * private void FixPasteDrumKitReferencesInPrograms(IEnumerable<IClipBoardPatch> clipBoardPatches) * { * foreach (var clipBoardPatch in clipBoardPatches) * { * var program = (IClipBoardProgram) clipBoardPatch; * foreach (var clipBoardDrumKit in DrumKits.CopiedPatches) * { * var drumKits = program.ReferencedDrumKits; * for (var drumKitIndex = 0; drumKitIndex < drumKits.CopiedPatches.Count(); drumKitIndex++) * { * var drumKit = program.ReferencedDrumKits.CopiedPatches[drumKitIndex]; * if (drumKit != clipBoardDrumKit) * { * continue; * } * * if ((drumKit.PasteDestination != null) && (program.PasteDestination != null)) * { * // When pasting to the same file, then it is not wanted to fix references, * // because a duplicate drumkit/program can exist before the original reference * // so it will be changed unnecessarily. * if (drumKit.OriginalLocation.Root != PastePcgMemory) * { * var changes = new Dictionary<IDrumKit, IDrumKit> * { * * * * //xxx * * * * * * {(IDrumKit) (drumKit.OriginalLocation), * (IDrumKit) (drumKit.PasteDestination)} * }; * * ((IProgram) (program.PasteDestination)).ReplaceDrumKit(changes); * } * program.ReferencedDrumKits.CopiedPatches[drumKitIndex] = null; // Prevent fixing it again * } * } * } * } * } */ /// <summary> /// /// </summary> private void FixPastePatchInSetListSlotsReferences() { foreach (IClipBoardPatch clipBoardPatch in SetListSlots.CopiedPatches) { IClipBoardSetListSlot clipBoardSetListSlot = (IClipBoardSetListSlot)clipBoardPatch; ISetListSlot setListSlot = (ISetListSlot)(clipBoardSetListSlot.PasteDestination); if ((setListSlot != null) && (clipBoardSetListSlot.Reference != null)) { // Fix reference to program/combi. IClipBoardPatch clipBoardReference = clipBoardSetListSlot.Reference; // When pasting to the same file (second condition below), then it is not wanted to fix references, // because a duplicate program/combi can exist before the original reference so it will be changed // unnecessarily. if ((clipBoardReference.PasteDestination != null) && (clipBoardSetListSlot.Reference.OriginalLocation.Root != PastePcgMemory)) { if (clipBoardReference.PasteDestination is IProgram) { IProgram program = (IProgram)(clipBoardReference.PasteDestination); setListSlot.UsedPatch = program; } else if (clipBoardReference.PasteDestination is ICombi) { ICombi combi = (ICombi)(clipBoardReference.PasteDestination); setListSlot.UsedPatch = combi; } else { throw new ApplicationException("Illegal clip board reference"); } setListSlot.RaisePropertyChanged(string.Empty, false); } } } }
/// <summary> /// /// </summary> /// <param name="patch"></param> public WindowEditMultipleSetListSlot(ISetListSlot patch) { InitializeComponent(); _patch = patch; }
/// <summary> /// /// </summary> /// <param name="patch"></param> public WindowEditSingleSetListSlot(ISetListSlot patch) { _patch = patch; InitializeComponent(); }
/// <summary> /// /// </summary> /// <param name="setListSource"></param> /// <param name="setListTarget"></param> /// <param name="combiBankTarget"></param> /// <param name="mainMidiChannel"></param> /// <param name="secondaryMidiChannel"></param> internal void Process(ISetList setListSource, ISetList setListTarget, Model.Common.Synth.PatchCombis.ICombiBank combiBankTarget, int mainMidiChannel, int secondaryMidiChannel) { int currentTargetSetListSlotIndex = 0; int currentTargetCombiIndex = 0; bool finishedPrematurely = false; string errorText = string.Empty; if (!setListSource.IsLoaded) { finishedPrematurely = true; errorText = PcgToolsResources.Strings.KeyboardSetupErrorSetListsNotPresent; //TODO page 178 manual } else if (setListTarget.CountFilledPatches > 0) { finishedPrematurely = true; errorText = PcgToolsResources.Strings.KeyboardSetupErrorTargetSetListNotEmpty; } else if (!combiBankTarget.IsWritable) { finishedPrematurely = true; errorText = PcgToolsResources.Strings.KeyboardSetupErrorTargetCombiBankNotPresent; } else { foreach (Model.Common.Synth.Meta.IPatch patch in setListSource.Patches.Where(patch => !((ISetListSlot)patch).IsEmptyOrInit)) { ISetListSlot sourceSetListSlot = (ISetListSlot)patch; if (currentTargetSetListSlotIndex >= setListTarget.Patches.Count) { finishedPrematurely = true; errorText = PcgToolsResources.Strings.KeyboardSetupErrorNotEnoughSetListSlotsInTargetSetList; break; } // copy set list slot to target set list. // change suffix sourcemidi sourceSetListSlot.PcgRoot.CopyPatch(sourceSetListSlot, setListTarget.Patches[currentTargetSetListSlotIndex]); Model.Common.Synth.Meta.IPatch targetSetListSlot = setListTarget.Patches[currentTargetSetListSlotIndex]; targetSetListSlot.SetNameSuffix($"/MC{mainMidiChannel}"); currentTargetSetListSlotIndex++; if (sourceSetListSlot.SelectedPatchType == SetListSlot.PatchType.Combi) { if (CopySecondaryPatches(setListTarget, combiBankTarget, mainMidiChannel, secondaryMidiChannel, sourceSetListSlot, ref currentTargetCombiIndex, ref finishedPrematurely, ref currentTargetSetListSlotIndex)) { break; } } } } if (finishedPrematurely) { // Show message box. Console.WriteLine(errorText); } }