private List <IUniqueDef> GetTicksSequence(Palette ticksPalette)
{
List <IUniqueDef> ticksSequence = new List <IUniqueDef>();
int msPosition = 0;
int[] transpositions = { 12, 14, 17 };
for (int i = 0; i < 3; ++i)
{
int[] contour = K.Contour(7, 4, 10 - i);
for (int j = 6; j >= 0; --j)
{
IUniqueDef ticks = ticksPalette.UniqueDurationDef(contour[j] - 1);
ticks.MsPosition = msPosition;
msPosition += ticks.MsDuration;
MidiChordDef iumdd = ticks as MidiChordDef;
if (iumdd != null)
{
iumdd.Transpose(transpositions[i] + contour[j]);
iumdd.AdjustVelocities(0.6);
}
ticksSequence.Add(ticks);
}
}
return(ticksSequence);
}
/// <summary>
/// The clefType must be one of the following strings "t", "t1", "t2", "t3", "b", "b1", "b2", "b3"
/// The followingUniqueMidiChordOrRestDef must be a MidiChordDef or UniqueMidiRestDef.
/// </summary>
public ClefChangeDef(string clefType, IUniqueDef followingUniqueChordOrRestDef)
: base()
{
#region check args
if (String.Equals(clefType, "t") == false &&
String.Equals(clefType, "t1") == false &&
String.Equals(clefType, "t2") == false &&
String.Equals(clefType, "t3") == false &&
String.Equals(clefType, "b") == false &&
String.Equals(clefType, "b1") == false &&
String.Equals(clefType, "b2") == false &&
String.Equals(clefType, "b3") == false)
{
Debug.Assert(false, "Unknown clef type.");
}
if (!(followingUniqueChordOrRestDef is MidiChordDef) &&
!(followingUniqueChordOrRestDef is InputChordDef) &&
!(followingUniqueChordOrRestDef is RestDef))
{
Debug.Assert(false, "Clef change must be followed by a chord or rest.");
}
#endregion
_id = "clefChange" + UniqueClefChangeIDNumber.ToString();
_clefType = clefType;
_followingChordOrRestDef = followingUniqueChordOrRestDef;
}
private TrkDef GetFlutter1(Palette palette)
{
List <IUniqueDef> flutter1 = new List <IUniqueDef>();
int msPosition = 0;
for (int i = 0; i < 7; ++i)
{
int[] contour = K.Contour(7, 11, 7);
IUniqueDef flutter = palette.UniqueDurationDef(contour[i] - 1);
flutter.MsPosition = msPosition;
msPosition += flutter.MsDuration;
flutter1.Add(flutter);
if (i != 3 && i != 5)
{
RestDef rest = new RestDef(msPosition, flutter.MsDuration);
msPosition += rest.MsDuration;
flutter1.Add(rest);
}
}
TrkDef furies3FlutterSequence1 = new TrkDef(this.MidiChannel, flutter1);
return(furies3FlutterSequence1);
}
internal void RemoveDuplicateClefDefs()
{
if (_uniqueDefs.Count > 1)
{
for (int i = _uniqueDefs.Count - 1; i > 0; --i)
{
IUniqueDef iud1 = _uniqueDefs[i];
if (iud1 is ClefDef)
{
for (int j = i - 1; j >= 0; --j)
{
IUniqueDef iud2 = _uniqueDefs[j];
if (iud2 is ClefDef)
{
if (string.Compare(((ClefDef)iud1).ClefType, ((ClefDef)iud2).ClefType) == 0)
{
_uniqueDefs.RemoveAt(i);
}
break;
}
}
}
}
AssertConsistency();
}
}
/// <summary>
/// Returns a deep clone of this TrkDef.
/// </summary>
public TrkDef DeepClone()
{
List <IUniqueDef> clonedLmdds = new List <IUniqueDef>();
foreach (IUniqueDef iu in this._uniqueDefs)
{
IUniqueDef clone = iu.DeepClone();
clonedLmdds.Add(clone);
}
// Clefchange symbols must point at the following object in their own VoiceDef
for (int i = 0; i < clonedLmdds.Count; ++i)
{
ClefChangeDef clone = clonedLmdds[i] as ClefChangeDef;
if (clone != null)
{
Debug.Assert(i < (clonedLmdds.Count - 1));
ClefChangeDef replacement = new ClefChangeDef(clone.ClefType, clonedLmdds[i + 1]);
clonedLmdds.RemoveAt(i);
clonedLmdds.Insert(i, replacement);
}
}
return(new TrkDef(this.MidiChannel, clonedLmdds));
}
/// <summary>
/// There is currently still one bar per system.
/// </summary>
protected void ReplaceConsecutiveRestsInBars(List <List <VoiceDef> > voicesPerStaffPerSystem)
{
foreach (List <VoiceDef> voicesPerStaff in voicesPerStaffPerSystem)
{
foreach (VoiceDef voice in voicesPerStaff)
{
// contains lists of consecutive rest indices
List <List <int> > restsToReplace = new List <List <int> >();
#region find the consecutive rests
List <int> consecRestIndices = new List <int>();
for (int i = 0; i < voice.UniqueDefs.Count - 1; i++)
{
MidiChordDef mcd1 = voice.UniqueDefs[i] as MidiChordDef;
MidiChordDef mcd2 = voice.UniqueDefs[i + 1] as MidiChordDef;
if (mcd1 == null && mcd2 == null)
{
if (!consecRestIndices.Contains(i))
{
consecRestIndices.Add(i);
}
consecRestIndices.Add(i + 1);
}
else
{
if (consecRestIndices != null && consecRestIndices.Count > 0)
{
restsToReplace.Add(consecRestIndices);
consecRestIndices = new List <int>();
}
}
if (i == voice.UniqueDefs.Count - 2 && consecRestIndices.Count > 0)
{
restsToReplace.Add(consecRestIndices);
}
}
#endregion
#region replace the consecutive rests
if (restsToReplace.Count > 0)
{
for (int i = restsToReplace.Count - 1; i >= 0; i--)
{
List <int> indToReplace = restsToReplace[i];
int msDuration = 0;
int msPosition = voice.UniqueDefs[indToReplace[0]].MsPosition;
for (int j = indToReplace.Count - 1; j >= 0; j--)
{
IUniqueDef iumdd = voice.UniqueDefs[indToReplace[j]];
Debug.Assert(iumdd.MsDuration > 0);
msDuration += iumdd.MsDuration;
voice.UniqueDefs.RemoveAt(indToReplace[j]);
}
RestDef replacementLmdd = new RestDef(msPosition, msDuration);
voice.UniqueDefs.Insert(indToReplace[0], replacementLmdd);
}
}
#endregion
}
}
}
/// <summary>
/// The clefType must be one of the following strings "t", "t1", "t2", "t3", "b", "b1", "b2", "b3"
/// The followingUniqueMidiChordOrRestDef must be a MidiChordDef or UniqueMidiRestDef.
/// </summary>
public ClefChangeDef(string clefType, IUniqueDef followingUniqueChordOrRestDef)
: base()
{
#region check args
if(String.Equals(clefType, "t") == false
&& String.Equals(clefType, "t1") == false
&& String.Equals(clefType, "t2") == false
&& String.Equals(clefType, "t3") == false
&& String.Equals(clefType, "b") == false
&& String.Equals(clefType, "b1") == false
&& String.Equals(clefType, "b2") == false
&& String.Equals(clefType, "b3") == false)
{
Debug.Assert(false, "Unknown clef type.");
}
if(!(followingUniqueChordOrRestDef is MidiChordDef)
&& !(followingUniqueChordOrRestDef is InputChordDef)
&& !(followingUniqueChordOrRestDef is RestDef))
{
Debug.Assert(false, "Clef change must be followed by a chord or rest.");
}
#endregion
_id = "clefChange" + UniqueClefChangeIDNumber.ToString();
_clefType = clefType;
_followingChordOrRestDef = followingUniqueChordOrRestDef;
}
private List <VoiceDef> WriteLowerStaff(int staffNumber, List <VoiceDef> topStaffBars)
{
List <VoiceDef> consecutiveBars = new List <VoiceDef>();
Krystal krystal = _krystals[staffNumber - 1];
Palette palette = _palettes[staffNumber - 1];
List <List <int> > strandValuesList = krystal.GetValues(krystal.Level);
Debug.Assert(topStaffBars.Count == strandValuesList.Count);
for (int barIndex = 0; barIndex < strandValuesList.Count; barIndex++)
{
VoiceDef topStaffVoice = topStaffBars[barIndex];
VoiceDef newVoice = new TrkDef((byte)(staffNumber - 1), new List <IUniqueDef>());
int currentMsPosition = topStaffVoice.UniqueDefs[0].MsPosition;
List <int> lowerStaffValueSequence = strandValuesList[barIndex];
List <int> lowerStaffMsDurations = LowerStaffMsDurations(topStaffVoice, lowerStaffValueSequence.Count);
for (int valueIndex = 0; valueIndex < lowerStaffValueSequence.Count; valueIndex++)
{
int value = lowerStaffValueSequence[valueIndex];
IUniqueDef noteDef = palette.UniqueDurationDef(value - 1);
noteDef.MsDuration = lowerStaffMsDurations[valueIndex];
noteDef.MsPosition = currentMsPosition;
currentMsPosition += noteDef.MsDuration;
newVoice.UniqueDefs.Add(noteDef);
}
consecutiveBars.Add(newVoice);
}
return(consecutiveBars);
}
/// <summary>
/// Returns a list having the position and duration of the originalRest.
/// The iLmdds have been put in(side) the original rest, either at the beginning, middle, or end.
/// </summary>
private List <IUniqueDef> GetReplacementList(IUniqueDef originalRest, VoiceDef iVoiceDef)
{
Debug.Assert(originalRest is RestDef);
Debug.Assert(iVoiceDef[0] is MidiChordDef || iVoiceDef[0] is InputChordDef);
Debug.Assert(iVoiceDef[iVoiceDef.Count - 1] is MidiChordDef || iVoiceDef[iVoiceDef.Count - 1] is InputChordDef);
List <IUniqueDef> rList = new List <IUniqueDef>();
if (iVoiceDef[0].MsPosition > originalRest.MsPosition)
{
RestDef rest1 = new RestDef(originalRest.MsPosition, iVoiceDef[0].MsPosition - originalRest.MsPosition);
rList.Add(rest1);
}
rList.AddRange(iVoiceDef.UniqueDefs);
int iLmddsEndMsPos = iVoiceDef[iVoiceDef.Count - 1].MsPosition + iVoiceDef[iVoiceDef.Count - 1].MsDuration;
int originalRestEndMsPos = originalRest.MsPosition + originalRest.MsDuration;
if (originalRestEndMsPos > iLmddsEndMsPos)
{
RestDef rest2 = new RestDef(iLmddsEndMsPos, originalRestEndMsPos - iLmddsEndMsPos);
rList.Add(rest2);
}
return(rList);
}
/// <summary>
/// Multiplies the MsDuration of each T from beginIndex to endIndex (exclusive) by factor.
/// If a MsDuration becomes less than minThreshold, the T (chord or rest) is removed.
/// The total duration of this VoiceDef changes accordingly.
/// </summary>
protected void AdjustMsDurations <T>(int beginIndex, int endIndex, double factor, int minThreshold = 100)
{
M.Assert(!(Container is Bar), "Cannot AdjustChordMsDurations inside a Bar.");
if (CheckIndices(beginIndex, endIndex))
{
M.Assert(factor >= 0);
for (int i = beginIndex; i < endIndex; ++i)
{
IUniqueDef iumdd = _uniqueDefs[i];
if (iumdd is T)
{
iumdd.MsDuration = (int)((double)iumdd.MsDuration * factor);
}
}
for (int i = _uniqueDefs.Count - 1; i >= 0; --i)
{
IUniqueDef iumdd = _uniqueDefs[i];
if (iumdd.MsDuration < minThreshold)
{
_uniqueDefs.RemoveAt(i);
}
}
SetMsPositionsReFirstUD();
AssertConsistency();
}
}
/// <summary>
/// removes the iUniqueDef from the list, and then resets the positions of all the iUniques in the list.
/// </summary>
public void Remove(IUniqueDef iUniqueDef)
{
Debug.Assert(_uniqueDefs.Count > 0);
Debug.Assert(_uniqueDefs.Contains(iUniqueDef));
_uniqueDefs.Remove(iUniqueDef);
SetMsPositions();
}
/// <summary>
/// Removes the iUniqueMidiDurationDef at index from the list, and then inserts the replacement at the same index.
/// </summary>
protected void _Replace(int index, IUniqueDef replacementIUnique)
{
Debug.Assert(index >= 0 && index < _uniqueDefs.Count);
_uniqueDefs.RemoveAt(index);
_uniqueDefs.Insert(index, replacementIUnique);
SetMsPositions();
}
/// <summary>
/// Multiplies the MsDuration of each T from beginIndex to (not including) endIndex by factor.
/// If a MsDuration becomes less than minThreshold, the T (chord or rest) is removed.
/// The total duration of this VoiceDef changes accordingly.
/// </summary>
protected void AdjustMsDurations <T>(int beginIndex, int endIndex, double factor, int minThreshold = 100)
{
CheckIndices(beginIndex, endIndex);
Debug.Assert(factor >= 0);
for (int i = 0; i < _uniqueDefs.Count; ++i)
{
IUniqueDef iumdd = _uniqueDefs[i];
if (i >= beginIndex && i < endIndex && iumdd is T)
{
iumdd.MsDuration = (int)((double)iumdd.MsDuration * factor);
}
}
for (int i = _uniqueDefs.Count - 1; i >= 0; --i)
{
IUniqueDef iumdd = _uniqueDefs[i];
if (iumdd.MsDuration < minThreshold)
{
_uniqueDefs.RemoveAt(i);
}
}
SetMsPositions();
}
/// <summary>
/// Sets Clytamnestra's _uniqueMidiDurationDefs for the whole piece including rests.
/// Barline positions are set later.
/// </summary>
private void SetUniqueMidiDurationDefs(TrkDef wind3)
{
Debug.Assert(_momentDefsListPerVerse.Count == 5);
List <int> verseMsPositions = new List <int>();
verseMsPositions.Add(wind3[8].MsPosition);
verseMsPositions.Add(wind3[20].MsPosition);
verseMsPositions.Add(wind3[33].MsPosition);
verseMsPositions.Add(wind3[49].MsPosition);
verseMsPositions.Add(wind3[70].MsPosition);
int currentVerseMsPosition = 0;
int currentEndMsPosition = 0;
IUniqueDef interludeRestDef = null;
for (int verseIndex = 0; verseIndex < 5; ++verseIndex)
{
currentVerseMsPosition = verseMsPositions[verseIndex];
interludeRestDef = new RestDef(currentEndMsPosition, currentVerseMsPosition - currentEndMsPosition);
_uniqueDefs.Add(interludeRestDef);
List <MomentDef> momentDefs = _momentDefsListPerVerse[verseIndex];
for (int momentDefIndex = 0; momentDefIndex < momentDefs.Count; ++momentDefIndex)
{
MomentDef momentDef = momentDefs[momentDefIndex];
momentDef.MsPosition += currentVerseMsPosition;
int restWidth = momentDef.MsWidth - momentDef.MaximumMsDuration;
IUniqueDef lmrd = null;
if (restWidth > 0)
{
momentDef.MsWidth -= restWidth;
lmrd = new RestDef(momentDef.MsPosition + momentDef.MsWidth, restWidth);
Debug.Assert(lmrd.MsDuration > 0);
}
MidiChordDef mcd = momentDef.MidiChordDefs[0];
IUniqueDef lmcd = mcd.DeepClone();
lmcd.MsPosition = momentDef.MsPosition;
lmcd.MsDuration = momentDef.MsWidth;
Debug.Assert(lmcd.MsDuration > 0);
_uniqueDefs.Add(lmcd);
if (lmrd != null)
{
_uniqueDefs.Add(lmrd);
}
currentEndMsPosition = _uniqueDefs[_uniqueDefs.Count - 1].MsPosition +
_uniqueDefs[_uniqueDefs.Count - 1].MsDuration;
}
}
interludeRestDef = new RestDef(currentEndMsPosition, wind3.EndMsPosition - currentEndMsPosition);
_uniqueDefs.Add(interludeRestDef);
}
protected void _Add(IUniqueDef iUniqueDef)
{
Debug.Assert(_uniqueDefs.Count > 0);
IUniqueDef lastLmdd = _uniqueDefs[_uniqueDefs.Count - 1];
iUniqueDef.MsPosition = lastLmdd.MsPosition + lastLmdd.MsDuration;
_uniqueDefs.Add(iUniqueDef);
}
public RestSymbol(Voice voice, IUniqueDef iumdd, int minimumCrotchetDurationMS, float fontHeight)
: base(voice, iumdd.MsDuration, iumdd.MsPosition, minimumCrotchetDurationMS, fontHeight)
{
if (iumdd is CautionaryChordDef)
{
Console.WriteLine("rest is CautionaryChordDef!");
}
LocalCautionaryChordDef = iumdd as CautionaryChordDef;
}
/// <summary>
/// removes the iUniqueDef from the list, and then resets the positions of all the iUniqueDefs in the list.
/// </summary>
public void Remove(IUniqueDef iUniqueDef)
{
M.Assert(_uniqueDefs.Count > 0);
M.Assert(_uniqueDefs.Contains(iUniqueDef));
_uniqueDefs.Remove(iUniqueDef);
SetMsPositionsReFirstUD();
AssertConsistency();
}
protected void _Insert(int index, IUniqueDef iUniqueDef)
{
M.Assert(!(Container is Bar && iUniqueDef.MsDuration > 0), "Cannot Insert IUniqueDefs that have msDuration inside a Bar.");
_uniqueDefs.Insert(index, iUniqueDef);
SetMsPositionsReFirstUD();
AssertConsistency();
}
/// <summary>
/// Returns the position of the end of the last UniqueMidiDurationDef
/// in the bar's first voice's UniqueMidiDurationDefs list.
/// </summary>
protected int GetEndMsPosition(List <VoiceDef> bar)
{
Debug.Assert(bar != null && bar.Count > 0 && bar[0].UniqueDefs.Count > 0);
List <IUniqueDef> lmdd = bar[0].UniqueDefs;
IUniqueDef lastLmdd = lmdd[lmdd.Count - 1];
int endMsPosition = lastLmdd.MsPosition + lastLmdd.MsDuration;
return(endMsPosition);
}
public RestSymbol(Voice voice, IUniqueDef iumdd, int minimumCrotchetDurationMS, float fontHeight)
: base(voice, iumdd.MsDuration, iumdd.MsPosition, minimumCrotchetDurationMS, fontHeight)
{
if(iumdd is CautionaryChordDef)
{
Console.WriteLine("rest is CautionaryChordDef!");
}
LocalCautionaryChordDef = iumdd as CautionaryChordDef;
}
/// <summary>
/// Remove the IUniques which start between startMsPos and (not including) endMsPos
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
public void RemoveBetweenMsPositions(int startMsPos, int endMsPos)
{
IUniqueDef iumdd = _uniqueDefs.Find(f => (f.MsPosition >= startMsPos) && (f.MsPosition < endMsPos));
while (iumdd != null)
{
_uniqueDefs.Remove(iumdd);
iumdd = _uniqueDefs.Find(f => (f.MsPosition >= startMsPos) && (f.MsPosition < endMsPos));
}
SetMsPositions();
}
/// <summary>
/// Old constructor, currently not used (03.05.2020), but retained for future inspection
/// </summary>
public RestSymbol(Voice voice, IUniqueDef iumdd, int absMsPosition, int minimumCrotchetDurationMS, double fontHeight)
: base(voice, iumdd.MsDuration, absMsPosition, minimumCrotchetDurationMS, fontHeight)
{
M.Assert(false); // 03.05.2020: don't use this constructor (to be inspected once work on midi info begins).
if (iumdd is CautionaryChordDef)
{
Console.WriteLine("rest is CautionaryChordDef!");
}
LocalCautionaryChordDef = iumdd as CautionaryChordDef;
}
/// <summary>
/// Removes the iUniqueMidiDurationDef at index from the list, and then inserts the replacement at the same index.
/// </summary>
protected void _Replace(int index, IUniqueDef replacementIUnique)
{
M.Assert(!(Container is Bar), "Cannot Replace IUniqueDefs inside a Bar.");
M.Assert(index >= 0 && index < _uniqueDefs.Count);
_uniqueDefs.RemoveAt(index);
_uniqueDefs.Insert(index, replacementIUnique);
SetMsPositionsReFirstUD();
AssertConsistency();
}
static void Drop(ElementCode context, string tableName, IUniqueDef unique)
{
if (unique == null)
{
return;
}
context.Add(SqlKeyword.AlterTable, SqlKeyword.IfExists);
context.Concat(tableName);
context.Add(SqlKeyword.DropConstraint, SqlKeyword.IfExists);
context.Concat(unique.Name);
context.Go();
}
/// <summary>
/// There is still one system per bar.
/// Each VoiceDef begins with an MNXCommon.Clef (taking small clefs into account).
/// An Exception will be thrown if a SmallClefDef is found on the lower voiceDef in a staff in the systems input.
/// Small clefs (if there are any) are copied from the top to the bottom voice (if there is one) on each staff.
/// Small clefs on lower voices on a staff have IsVisible set to false.
/// </summary>
/// <param name="systems"></param>
public void ConvertVoiceDefsToNoteObjects(List <SvgSystem> systems)
{
byte[] currentChannelVelocities = new byte[systems[0].Staves.Count];
var topVoiceSmallClefs = new List <SmallClef>();
int systemAbsMsPos = 0;
for (int systemIndex = 0; systemIndex < systems.Count; ++systemIndex)
{
SvgSystem system = systems[systemIndex];
system.AbsStartMsPosition = systemAbsMsPos;
int msPositionReVoiceDef = 0;
for (int staffIndex = 0; staffIndex < system.Staves.Count; ++staffIndex)
{
Staff staff = system.Staves[staffIndex];
msPositionReVoiceDef = 0;
topVoiceSmallClefs.Clear();
for (int voiceIndex = 0; voiceIndex < staff.Voices.Count; ++voiceIndex)
{
Voice voice = staff.Voices[voiceIndex];
voice.VoiceDef.AgglomerateRests();
msPositionReVoiceDef = 0;
List <IUniqueDef> iuds = voice.VoiceDef.UniqueDefs;
M.Assert(iuds[0] is ClefDef || iuds[0] is MNX.Common.Clef); /** <-------------- **/
for (int iudIndex = 0; iudIndex < iuds.Count; ++iudIndex)
{
IUniqueDef iud = voice.VoiceDef.UniqueDefs[iudIndex];
int absMsPosition = systemAbsMsPos + msPositionReVoiceDef;
NoteObject noteObject =
SymbolSet.GetNoteObject(voice, absMsPosition, iud, iudIndex, ref currentChannelVelocities[staffIndex]);
if (noteObject is SmallClef smallClef)
{
if (voiceIndex == 0)
{
if (staff.Voices.Count > 1)
{
topVoiceSmallClefs.Add(smallClef);
}
}
else
{
throw new Exception("SmallClefs may not be defined for a lower voice. They will be copied from the top voice");
}
}
if (iud is IUniqueSplittableChordDef iscd && iscd.MsDurationToNextBarline != null)
{
msPositionReVoiceDef += (int)iscd.MsDurationToNextBarline;
}
/// <summary>
/// Remove the IUniqueDefs which start between startMsPosReFirstIUD and (not including) endMsPosReFirstIUD
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
public void RemoveBetweenMsPositions(int startMsPosReFirstIUD, int endMsPosReFirstIUD)
{
IUniqueDef iumdd = _uniqueDefs.Find(f => (f.MsPositionReFirstUD >= startMsPosReFirstIUD) && (f.MsPositionReFirstUD < endMsPosReFirstIUD));
while (iumdd != null)
{
_uniqueDefs.Remove(iumdd);
iumdd = _uniqueDefs.Find(f => (f.MsPositionReFirstUD >= startMsPosReFirstIUD) && (f.MsPositionReFirstUD < endMsPosReFirstIUD));
}
SetMsPositionsReFirstUD();
AssertConsistency();
}
private void WriteDurationSymbolsForStrandInTopStaff(VoiceDef voice, int barIndex, List <int> originalStrandValues, ref int msPosition)
{
Palette palette = _palettes[0]; // top templateDefs
for (int valueIndex = 0; valueIndex < originalStrandValues.Count; valueIndex++)
{
int value = originalStrandValues[valueIndex];
IUniqueDef noteDef = palette.UniqueDurationDef(value - 1);
noteDef.MsPosition = msPosition;
msPosition += noteDef.MsDuration;
voice.UniqueDefs.Add(noteDef);
}
}
private void InsertVoiceDefInRest(int restIndex, VoiceDef iVoiceDef)
{
List <IUniqueDef> lmdds = _uniqueDefs;
IUniqueDef rest = lmdds[restIndex];
List <IUniqueDef> replacement = GetReplacementList(rest, iVoiceDef);
int replacementStart = replacement[0].MsPosition;
int replacementEnd = replacement[replacement.Count - 1].MsPosition + replacement[replacement.Count - 1].MsDuration;
int restStart = rest.MsPosition;
int restEnd = rest.MsPosition + rest.MsDuration;
Debug.Assert(restStart == replacementStart && restEnd == replacementEnd);
lmdds.RemoveAt(restIndex);
lmdds.InsertRange(restIndex, replacement);
}
private void WriteVoiceMidiDurationDefs1(TrkDef trkDef, Palette palette)
{
int msPosition = 0;
int bar1ChordMsSeparation = 1500;
for (int i = 0; i < palette.Count; ++i)
{
IUniqueDef durationDef = palette.UniqueDurationDef(i);
durationDef.MsPosition = msPosition;
RestDef restDef = new RestDef(msPosition + durationDef.MsDuration, bar1ChordMsSeparation - durationDef.MsDuration);
msPosition += bar1ChordMsSeparation;
trkDef.UniqueDefs.Add(durationDef);
trkDef.UniqueDefs.Add(restDef);
}
}
public override NoteObject GetNoteObject(Voice voice, IUniqueDef iud, bool firstDefInVoice,
ref byte currentVelocity, float musicFontHeight)
{
NoteObject noteObject = null;
CautionaryChordDef cautionaryChordDef = iud as CautionaryChordDef;
MidiChordDef midiChordDef = iud as MidiChordDef;
InputChordDef inputChordDef = iud as InputChordDef;
RestDef restDef = iud as RestDef;
ClefChangeDef clefChangeDef = iud as ClefChangeDef;
PageFormat pageFormat = voice.Staff.SVGSystem.Score.PageFormat;
float cautionaryFontHeight = pageFormat.CautionaryNoteheadsFontHeight;
int minimumCrotchetDuration = pageFormat.MinimumCrotchetDuration;
if (cautionaryChordDef != null && firstDefInVoice)
{
CautionaryChordSymbol cautionaryChordSymbol = new CautionaryChordSymbol(voice, cautionaryChordDef, cautionaryFontHeight);
noteObject = cautionaryChordSymbol;
}
else if (midiChordDef != null)
{
OutputChordSymbol outputChordSymbol = new OutputChordSymbol(voice, midiChordDef, minimumCrotchetDuration, musicFontHeight);
if (midiChordDef.MidiVelocity != currentVelocity)
{
outputChordSymbol.AddDynamic(midiChordDef.MidiVelocity, currentVelocity);
currentVelocity = midiChordDef.MidiVelocity;
}
noteObject = outputChordSymbol;
}
else if (inputChordDef != null)
{
InputChordSymbol inputChordSymbol = new InputChordSymbol(voice, inputChordDef, minimumCrotchetDuration, musicFontHeight);
noteObject = inputChordSymbol;
}
else if (restDef != null)
{
RestSymbol restSymbol = new RestSymbol(voice, iud, minimumCrotchetDuration, musicFontHeight);
noteObject = restSymbol;
}
else if (clefChangeDef != null)
{
ClefChangeSymbol clefChangeSymbol = new ClefChangeSymbol(voice, clefChangeDef.ClefType, cautionaryFontHeight, ((IUniqueDef)iud).MsPosition);
noteObject = clefChangeSymbol;
}
return(noteObject);
}
/// <summary>
/// Combines all consecutive rests.
/// </summary>
public void AgglomerateRests()
{
if (_uniqueDefs.Count > 1)
{
for (int i = _uniqueDefs.Count - 1; i > 0; --i)
{
IUniqueDef lmdd2 = _uniqueDefs[i];
IUniqueDef lmdd1 = _uniqueDefs[i - 1];
if (lmdd2 is RestDef && lmdd1 is RestDef)
{
lmdd1.MsDuration += lmdd2.MsDuration;
_uniqueDefs.RemoveAt(i);
}
}
}
}
/// <summary>
/// Old constructor, currently not used (03.05.2020), but retained for future inspection
/// </summary>
public OutputRestSymbol(Voice voice, IUniqueDef iumdd, int absMsPosition, PageFormat pageFormat)
: base(voice, iumdd, absMsPosition, pageFormat.MinimumCrotchetDuration, pageFormat.MusicFontHeight)
{
M.Assert(false); // 03.05.2020: don't use this constructor (to be inspected once work on midi info begins).
if (iumdd is MidiRestDef mrd)
{
_midiRestDef = mrd;
}
// This needs testing!!
if (iumdd is CautionaryChordDef ccd)
{
Console.WriteLine("rest is CautionaryChordDef!");
LocalCautionaryChordDef = ccd;
}
}
/// <summary>
/// Inserts the iUniqueDef in the list at the given index, and then
/// resets the positions of all the uniqueDefs in the list.
/// </summary>
public override void Insert(int index, IUniqueDef iUniqueDef)
{
Debug.Assert(iUniqueDef is InputChordDef || iUniqueDef is RestDef || iUniqueDef is CautionaryChordDef);
_Insert(index, iUniqueDef);
}
/// <summary>
/// Forbidden
/// </summary>
public override void Insert(int index, IUniqueDef iUniqueDef)
{
Debug.Assert(false, ForbiddenFunctionMsg);
}
public abstract NoteObject GetNoteObject(Voice voice, IUniqueDef iud, bool firstLmddInVoice,
ref byte currentVelocity, float musicFontHeight);
/// <summary>
/// Forbidden
/// </summary>
public override void Replace(int index, IUniqueDef replacementIUnique)
{
Debug.Assert(false, ForbiddenFunctionMsg);
}
/// <summary>
/// Appends the new iUniqueDef to the end of the list. Sets the MsPosition of the iUniqueDef re the first iUniqueDef in the list.
/// Automatically sets the iUniqueDef's msPosition.
/// Used by Block.PopBar(...), so accepts a CautionaryChordDef argument.
/// </summary>
/// <param name="iUniqueDef"></param>
public override void Add(IUniqueDef iud)
{
Debug.Assert(iud is InputChordDef || iud is RestDef || iud is CautionaryChordDef || iud is ClefChangeDef);
_Add(iud);
}
/// <summary>
/// Appends the new iUniqueDef to the end of the list.
/// </summary>
/// <param name="iUniqueDef"></param>
public override void Add(IUniqueDef iUniqueDef)
{
Debug.Assert(!(iUniqueDef is MidiChordDef));
_Add(iUniqueDef);
}
/// <summary>
/// Inserts the iUniqueDef in the list at the given index, and then
/// resets the positions of all the uniqueDefs in the list.
/// </summary>
public override void Insert(int index, IUniqueDef iUniqueDef)
{
Debug.Assert(_gamut != null);
AssertPitches(iUniqueDef);
base.Insert(index, iUniqueDef);
SetBeamEnd();
}
/// <summary>
/// Removes the iUniqueDef at index from the list, and then inserts the replacement at the same index.
/// </summary>
public override void Replace(int index, IUniqueDef replacementIUnique)
{
Debug.Assert(_gamut != null);
AssertPitches(replacementIUnique);
base.Replace(index, replacementIUnique);
SetBeamEnd();
}
/// <summary>
/// Inserts the iUniqueDef in the list at the given index, and then
/// resets the positions of all the uniqueDefs in the list.
/// </summary>
public override void Insert(int index, IUniqueDef iUniqueDef)
{
Debug.Assert(iUniqueDef is MidiChordDef || iUniqueDef is RestDef || iUniqueDef is ClefChangeDef);
_Insert(index, iUniqueDef);
}
public override NoteObject GetNoteObject(Voice voice, int absMsPosition, IUniqueDef iud, bool firstDefInVoice,
ref byte currentVelocity, float musicFontHeight)
{
NoteObject noteObject = null;
CautionaryChordDef cautionaryChordDef = iud as CautionaryChordDef;
MidiChordDef midiChordDef = iud as MidiChordDef;
InputChordDef inputChordDef = iud as InputChordDef;
RestDef restDef = iud as RestDef;
ClefChangeDef clefChangeDef = iud as ClefChangeDef;
PageFormat pageFormat = voice.Staff.SVGSystem.Score.PageFormat;
float cautionaryFontHeight = pageFormat.CautionaryNoteheadsFontHeight;
int minimumCrotchetDuration = pageFormat.MinimumCrotchetDuration;
if(cautionaryChordDef != null && firstDefInVoice)
{
if(cautionaryChordDef.NotatedMidiVelocities != null)
{
CautionaryOutputChordSymbol cautionaryOutputChordSymbol = new CautionaryOutputChordSymbol(voice, cautionaryChordDef, absMsPosition, cautionaryFontHeight);
noteObject = cautionaryOutputChordSymbol;
}
else
{
CautionaryInputChordSymbol cautionaryInputChordSymbol = new CautionaryInputChordSymbol(voice, cautionaryChordDef, absMsPosition, cautionaryFontHeight);
noteObject = cautionaryInputChordSymbol;
}
}
else if(midiChordDef != null)
{
OutputChordSymbol outputChordSymbol = new OutputChordSymbol(voice, midiChordDef, absMsPosition, minimumCrotchetDuration, musicFontHeight);
if(this._coloredVelocities == true)
{
outputChordSymbol.SetNoteheadColors();
}
else if(midiChordDef.NotatedMidiVelocities[0] != currentVelocity)
{
outputChordSymbol.AddDynamic(midiChordDef.NotatedMidiVelocities[0], currentVelocity);
currentVelocity = midiChordDef.NotatedMidiVelocities[0];
}
noteObject = outputChordSymbol;
}
else if(inputChordDef != null)
{
InputChordSymbol inputChordSymbol = new InputChordSymbol(voice, inputChordDef, absMsPosition, minimumCrotchetDuration, musicFontHeight);
noteObject = inputChordSymbol;
}
else if(restDef != null)
{
RestSymbol restSymbol = new RestSymbol(voice, iud, absMsPosition, minimumCrotchetDuration, musicFontHeight);
noteObject = restSymbol;
}
else if(clefChangeDef != null)
{
ClefChangeSymbol clefChangeSymbol = new ClefChangeSymbol(voice, clefChangeDef.ClefType, absMsPosition, cautionaryFontHeight);
noteObject = clefChangeSymbol;
}
return noteObject;
}
/// <summary>
/// Removes the iUniqueDef at index from the list, and then inserts the replacement at the same index.
/// </summary>
public void Replace(int index, IUniqueDef replacementIUnique)
{
Debug.Assert(!(replacementIUnique is MidiChordDef));
_Replace(index, replacementIUnique);
}
/// <summary>
/// Forbidden
/// </summary>
public override void Add(IUniqueDef iUniqueDef)
{
Debug.Assert(false, ForbiddenFunctionMsg);
}
/// <summary>
/// Returns a list having the position and duration of the originalRest.
/// The iLmdds have been put in(side) the original rest, either at the beginning, middle, or end.
/// </summary>
private List<IUniqueDef> GetReplacementList(IUniqueDef originalRest, VoiceDef iVoiceDef)
{
Debug.Assert(originalRest is RestDef);
Debug.Assert(iVoiceDef[0] is MidiChordDef || iVoiceDef[0] is InputChordDef);
Debug.Assert(iVoiceDef[iVoiceDef.Count - 1] is MidiChordDef || iVoiceDef[iVoiceDef.Count - 1] is InputChordDef);
List<IUniqueDef> rList = new List<IUniqueDef>();
if(iVoiceDef[0].MsPositionReFirstUD > originalRest.MsPositionReFirstUD)
{
RestDef rest1 = new RestDef(originalRest.MsPositionReFirstUD, iVoiceDef[0].MsPositionReFirstUD - originalRest.MsPositionReFirstUD);
rList.Add(rest1);
}
rList.AddRange(iVoiceDef.UniqueDefs);
int iudEndMsPosReFirstIUD = iVoiceDef[iVoiceDef.Count - 1].MsPositionReFirstUD + iVoiceDef[iVoiceDef.Count - 1].MsDuration;
int originalRestEndMsPosReFirstIUD = originalRest.MsPositionReFirstUD + originalRest.MsDuration;
if(originalRestEndMsPosReFirstIUD > iudEndMsPosReFirstIUD)
{
RestDef rest2 = new RestDef(iudEndMsPosReFirstIUD, originalRestEndMsPosReFirstIUD - iudEndMsPosReFirstIUD);
rList.Add(rest2);
}
return rList;
}
/// <summary>
/// Inserts the iUniqueDef in the list at the given index, and then
/// resets the positions of all the uniqueDefs in the list.
/// </summary>
public override void Insert(int index, IUniqueDef iUniqueDef)
{
Debug.Assert(!(iUniqueDef is MidiChordDef));
_Insert(index, iUniqueDef);
}
/// <summary>
/// A Debug.Assert fails if the iUniqueDef is a MidichordDef containing pitches that are not in the gamut
/// or if the iUniqueDef is a CautionaryChordDef.
/// </summary>
/// <param name="iUniqueDef"></param>
private void AssertPitches(IUniqueDef iUniqueDef)
{
MidiChordDef mcd = iUniqueDef as MidiChordDef;
if(mcd != null)
{
Debug.Assert(_gamut.ContainsAllPitches(mcd));
}
if(iUniqueDef is CautionaryChordDef)
{
Debug.Assert(false, "Grps cannot contain CautionaryChordDefs");
}
}
/// <summary>
/// Removes the iUniqueDef at index from the list, and then inserts the replacement at the same index.
/// </summary>
public virtual void Replace(int index, IUniqueDef replacementIUnique)
{
Debug.Assert(replacementIUnique is MidiChordDef || replacementIUnique is RestDef);
_Replace(index, replacementIUnique);
}
/// <summary>
/// Appends a new MidiChordDef, RestDef, or ClefChangeDef to the end of the list.
/// IUniqueDefs in Grps cannot be CautionaryChordDefs.
/// Automatically sets the iUniqueDef's msPosition.
/// Used by Block.PopBar(...), so accepts a CautionaryChordDef argument.
/// CautionaryChordDefs are however not allowed in Grps.
/// </summary>
public override void Add(IUniqueDef iUniqueDef)
{
Debug.Assert(_gamut != null);
AssertPitches(iUniqueDef);
base.Add(iUniqueDef);
SetBeamEnd();
}
/// <summary>
/// Appends the new MidiChordDef, RestDef, CautionaryChordDef or ClefChangeDef to the end of the list.
/// Automatically sets the iUniqueDef's msPosition.
/// Used by Block.PopBar(...), so accepts a CautionaryChordDef argument.
/// </summary>
public override void Add(IUniqueDef iUniqueDef)
{
Debug.Assert(iUniqueDef is MidiChordDef || iUniqueDef is RestDef || iUniqueDef is CautionaryChordDef || iUniqueDef is ClefChangeDef);
_Add(iUniqueDef);
}
