private void ValidateField(NoteValue e, NoteField noteField)
{
// required
if (noteField.Required && e.Value == "")
{
throw new AppException(string.Format("Field '{0}' is required.", noteField.Title));
}
// types
if (e.Value == "") // return if there is no value to be converted
{
return;
}
if ((noteField.Type == "datetime" || noteField.Type == "date") && !DateTime.TryParse(e.Value, out _))
{
throw new AppException(String.Format("Field '{0}' does not contain a valid date.", noteField.Title));
}
if ((noteField.Type == "boolean" || noteField.Type == "bool") && !bool.TryParse(e.Value, out _))
{
throw new AppException(String.Format("Field '{0}' does not contain a valid bool.", noteField.Title));
}
if (noteField.Type == "number" && !double.TryParse(e.Value, out _))
{
throw new AppException(String.Format("Field '{0}' does not contain a valid number.", noteField.Title));
}
}
public MusicalNoteMock(NoteValue pNoteValue, int pNumber, string pNoteName)
{
fValue = pNoteValue;
fNumber = pNumber;
fNoteName = pNoteName;
this.Volume = 0;
}
public static NoteValue Shift(this NoteValue pNote, Interval pInterval)
{
int noteAsInt = (int)pNote;
int intervalAsInt = (int)pInterval;
return((NoteValue)((noteAsInt + intervalAsInt + 1) % 12));
}
public void Can_Create_Note_With_Valid_Value(NoteValue v)
{
var note = new Note(v);
note.StringValue.Should().NotBeEmpty();
PossibleNotes.Should().Contain(note.StringValue);
}
/// <summary>
/// Add a rest for the given length for the current beat.
/// </summary>
/// <param name="restLength">Duration of wait specified as a note value.</param>
public void AddRest(NoteValue restLength)
{
AddNotes(new Note
{
NamedValue = restLength
});
}
/// <summary>
/// Add a rest for the given length for the current beat.
/// </summary>
/// <param name="restLength">Duration of wait specified as a note value.</param>
/// <param name="dots">Total dotted note length extensions to apply.</param>
public void AddRest(NoteValue restLength, int dots)
{
AddNotes(new Note
{
NamedValue = restLength, Dots = dots
});
}
public void DrawNoteValueAugment(NoteValue noteValue, double position, double stringIndex)
{
var x = this.Location.X + position + this.Style.NoteValueAugmentOffset;
var y = this.Owner.GetStringSpacePosition(stringIndex);
this.PrimitiveRenderer.DrawNoteValueAugment(noteValue.Augment, x, y);
}
public void GtSceneGuitarNoteValueAndNumber(int pString, int pFret, NoteValue pNoteValue, int pNoteNumber)
{
var guitarNote = new GtSceneGuitarNote(new BeatTick(1, 0), new BeatTick(2, 0), pString, pFret);
Assert.AreEqual(pNoteValue, guitarNote.NoteValue);
Assert.AreEqual(pNoteNumber, guitarNote.NoteNumber);
}
/// <summary>
/// Note Constructor.
/// Generates a new object of class Note with a given octave, duration, pitch,
/// sharp and flat
/// </summary>
/// <param name="oct">Octave</param>
/// <param name="d">NoteValue</param>
/// <param name="pitch">String representing the Pitch</param>
/// <param name="posit">Position</param>
/// <param name="sharp">(#)</param>
/// <param name="flat">(b)</param>
public Note(int oct, NoteValue d, String pitch, int posit, Boolean sharp, Boolean flat)
{
Octave = oct;
Duration = d;
Pitch = pitch;
Sharp = sharp;
Flat = flat;
Position = posit;
}
public static string AsSharpedString(this NoteValue value)
{
string result = "";
switch (value)
{
case NoteValue.C:
result = "C";
break;
case NoteValue.Db:
result = "C#";
break;
case NoteValue.D:
result = "D";
break;
case NoteValue.Eb:
result = "D#";
break;
case NoteValue.E:
result = "E";
break;
case NoteValue.F:
result = "F";
break;
case NoteValue.Gb:
result = "F#";
break;
case NoteValue.G:
result = "G";
break;
case NoteValue.Ab:
result = "G#";
break;
case NoteValue.A:
result = "A";
break;
case NoteValue.Bb:
result = "A#";
break;
case NoteValue.B:
result = "B";
break;
}
return(result);
}
public Sprite GetStaveUnitSprite(UnitFunction a_Function,
NoteValue a_Value,
SpriteType a_Type)
{
var spriteEntry = m_StaveUnits.First(a_Entry => a_Entry.Function == a_Function &&
a_Entry.Value == a_Value);
return(a_Type == SpriteType.MAIN ? spriteEntry.MainSprite : spriteEntry.GlowSprite);
}
/// <summary>
/// Note Constructor.
/// Generates a new object of class Note with a given octave, duration and pitch.
/// </summary>
/// <param name="oct">Octave</param>
/// <param name="d">NoteValue</param>
/// <param name="pitch">String representing the Pitch</param>
/// <param name="posit">Position</param>
public Note(int oct, NoteValue d, String pitch, int posit)
{
Octave = oct;
Duration = d;
Pitch = pitch;
Sharp = false;
Flat = false;
Position = posit;
}
public static int NoteLocation(NoteValue value, out bool isSharp)
{
isSharp = false;
switch (value)
{
case NoteValue.c_low: return(0);
case NoteValue.c_sharp_low: isSharp = true; return(0);
case NoteValue.d: return(1);
case NoteValue.d_sharp: isSharp = true; return(1);
case NoteValue.e: return(2);
case NoteValue.f: return(3);
case NoteValue.f_sharp: isSharp = true; return(3);
case NoteValue.g: return(4);
case NoteValue.g_sharp: isSharp = true; return(4);
case NoteValue.a: return(5);
case NoteValue.a_sharp: isSharp = true; return(5);
case NoteValue.b: return(6);
case NoteValue.c: return(7);
case NoteValue.c_sharp: isSharp = true; return(7);
case NoteValue.d_high: return(8);
case NoteValue.d_sharp_high: isSharp = true; return(8);
case NoteValue.e_high: return(9);
case NoteValue.f_high: return(10);
case NoteValue.f_sharp_high: isSharp = true; return(10);
case NoteValue.g_high: return(11);
case NoteValue.g_sharp_high: isSharp = true; return(11);
case NoteValue.a_high: return(12);
case NoteValue.a_sharp_high: isSharp = true; return(12);
case NoteValue.b_high: return(13);
case NoteValue.c_high: return(14);
}
return(0);
}
public static string Note(Note note, NoteValue length, bool dotted = false, string color = "#000000")
{
var accid = string.Empty;
if (note.Accidental != Accidental.n)
{
accid = $"accid='{note.Accidental}'";
}
return($@"<note dur='{(int)length}' color='{color}' pname='{note.Name}' oct='{note.Register}' {accid} />");
}
public void Initialize(Team a_Team, UnitFunction a_Function, NoteValue a_Value)
{
Function = a_Function;
Value = a_Value;
Func <Sprites.SpriteType, Sprite> getSprite = a_Type =>
Sprites.Instance.GetStaveUnitSprite(a_Function, a_Value, a_Type);
Initialize(a_Team, getSprite(Sprites.SpriteType.MAIN),
getSprite(Sprites.SpriteType.GLOW));
}
public async Task <bool> IsExistNoteTextInListNote(NoteValue noteValue)
{
var existItem = await Read <Note>()
.AnyAsync(
i => i.ListNoteId == noteValue.ListNoteId &&
noteValue.Id != i.Id &&
i.Text == noteValue.Text
);
return(existItem);
}
private static PlayLineNotes GetNote(this NoteValue value, int order, ITempoForBars tempo, List <Note.Note> asNotes, List <Note.Note> deNotes, int noteNumber)
{
return(new PlayLineNotes()
{
IsPlayed = false,
Length = tempo.LengthByTempo(value),
Note = noteNumber != 0 ? asNotes.FirstOrDefault(a => a.Number == noteNumber) : null,
Order = order,
Silence = false
});
}
protected bool FindNote(NoteValue pNote)
{
foreach (var note in this.fNotes)
{
if (note.Value == pNote)
{
return(true);
}
}
return(false);
}
private NoteValue CalculateTheActualNote(NoteValue noteValue, int pFret)
{
int fret = pFret;
while (fret > 0)
{
noteValue = noteValue.Shift(Interval.MinorSecond);
fret--;
}
return(noteValue);
}
public static NoteValueBuilder CreateDefaultBuilder()
{
var todoList = new NoteValue()
{
Text = DefaultValues.NoteText,
ListNoteId = DefaultValues.NoteListNoteId,
IsCompleted = DefaultValues.NoteIsCompleted,
IsPublic = DefaultValues.NoteIsPublic,
DueDate = DefaultValues.NoteDueDate
};
return(new NoteValueBuilder(todoList));
}
public static Interval Interval(this NoteValue pNote1, NoteValue pNote2, out int pOctaves)
{
int difference = (int)pNote2 - (int)pNote1 - 1;
pOctaves = 0;
while (difference < 0)
{
difference += 12;
pOctaves++;
}
return((Interval)(difference % 12));
}
public override bool TryParse(Scanner scanner, out NoteValueNode result)
{
var anchor = scanner.MakeAnchor();
result = new NoteValueNode();
LiteralNode <BaseNoteValue> baseNoteValue;
if (!Parser.TryReadBaseNoteValue(scanner, this, out baseNoteValue))
{
this.Report(LogLevel.Error, scanner.LastReadRange, Messages.Error_NoteValueExpected);
result = null;
return(false);
}
result.Base = baseNoteValue;
if (scanner.Expect('/')) //tuplet
{
LiteralNode <int> tuplet;
if (!Parser.TryReadInteger(scanner, out tuplet))
{
this.Report(LogLevel.Error, scanner.LastReadRange, Messages.Error_TupletValueExpected);
result = null;
return(false);
}
if (!NoteValue.IsValidTuplet(tuplet.Value))
{
this.Report(LogLevel.Error, scanner.LastReadRange, Messages.Error_InvalidTuplet);
result = null;
return(false);
}
result.Tuplet = tuplet;
}
LiteralNode <NoteValueAugment> augment;
if (!Parser.TryReadNoteValueAugment(scanner, this, out augment))
{
result = null;
return(false);
}
result.Augment = augment;
result.Range = anchor.Range;
return(true);
}
public static ChordOrigin FromParseResults(NoteValue root,
Accidental accidental,
KnownChordKind knownChordKind,
ChordExtensions.ExtensionBase extensionBase,
IEnumerable <ChordExtensions.Extension> extensions,
Tuple <NoteValue, Accidental> inversionOrBass) => new ChordOrigin
{
ChordKind = knownChordKind,
Extensions = extensions,
ExtensionBase = extensionBase,
Root = new Note(root, accidental),
BassNoteOrInversion =
inversionOrBass != null ? new Note(inversionOrBass.Item1, inversionOrBass.Item2) : null
};
public Note AddNote(NoteValue noteValue = null, int?listNoteId = null)
{
listNoteId ??= AddListNote().Id;
noteValue ??= NoteValueBuilder
.CreateDefaultBuilder()
.Configure(i =>
{
i.ListNoteId = listNoteId.Value;
})
.Build();
var note = _mapper.Map <NoteValue, Note>(noteValue);
_repo.Add(note).GetAwaiter().GetResult();
return(note);
}
//private static string MIDI_for_whom_the_bell_tolls = TestConfig.AudioPath + "metallica-for_whom_the_bell_tolls.mid";
private void TestFirstNotePosition(NoteValue pNoteValue, string pNoteId, int pString, int pPosition)
{
var midiEvents = new MidiEventCollection();
midiEvents.Add(new NoteOn(0, 1, pNoteId, 100));
midiEvents.Add(new NoteOn(120, 1, pNoteId, 0));
var midiImporter = new GuitarMidiImporter(midiEvents, 120);
var firstScoreNote = midiImporter.ScoreNotes.ElementAt(0).Value;
Assert.AreEqual(pNoteValue, firstScoreNote.Note.Value, firstScoreNote.NoteId);
Assert.AreEqual(pString, firstScoreNote.NotePositions.ElementAt(0).Value.String, firstScoreNote.NoteId);
Assert.AreEqual(pPosition, firstScoreNote.NotePositions.ElementAt(0).Value.Fret, firstScoreNote.NoteId);
}
public static string Chord(List <Note> chord, NoteValue length, bool dotted = false, string color = "#000000")
{
var notes = string.Join("\r\n", chord.Select(c =>
{
var accid = string.Empty;
if (c.Accidental != Accidental.n)
{
accid = $"accid='{c.Accidental}'";
}
return($"<note pname='{c.Name}' oct='{c.Register}' {accid}/>");
}));
return
($@"<chord dur='{(int)length}' color='{color}'>
{notes}
</chord>");
}
public static double LengthByTempo(this ITempoForBars tempo, NoteValue value)
{
switch (value)
{
case NoteValue.Quarter:
return(tempo.QuarterLength);
case NoteValue.DottedQuarter:
return(tempo.DottedQuarterLength);
case NoteValue.Half:
return(tempo.HalfLength);
case NoteValue.Eighth:
return(tempo.EighthLength);
case NoteValue.DottedEighth:
return(tempo.DottedEighthLength);
case NoteValue.Sixteenth:
return(tempo.SixteenthLength);
case NoteValue.DottedSixteenth:
return(tempo.DottedSixteenthLength);
case NoteValue.ThirtySecond:
return(tempo.ThirtySecondLength);
case NoteValue.DottedThirtySecond:
return(tempo.DottedThirtySecondLength);
case NoteValue.SixtyFourth:
return(tempo.SixtyFourthLength);
case NoteValue.DottedSixtyFourth:
return(tempo.DottedSixtyFourthLength);
case NoteValue.HundredTwentyEighth:
return(tempo.HundredTwentyEighthLength);
default:
return(0);
}
}
public override void Draw(Graphics g, Point drawLocation)
{
PointF drawPoint = new PointF(
noteRect.X - Position.Lane * ScoreInfo.UnitLaneWidth - drawLocation.X + ScoreLane.scoreWidth,
Location.Y - drawLocation.Y);
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
using (Font myFont = new Font("MS UI Gothic", ScoreInfo.FontSize, FontStyle.Bold))
{
g.DrawString(
"x" + NoteValue.ToString(),
myFont,
Brushes.Red,
new PointF(
drawPoint.X + adjustPoint.X,
drawPoint.Y + adjustPoint.Y));
}
using (Pen myPen = new Pen(Color.Red, 1))
{
g.DrawLine(
myPen,
drawPoint.X - ScoreLane.scoreWidth,
drawPoint.Y,
drawPoint.X,
drawPoint.Y);
}
#if DEBUG
/*
* using (Pen myPen = new Pen(Color.White))
* {
* RectangleF hitRect = new RectangleF(
* noteRect.X - Position.Lane * ScoreInfo.MinLaneWidth + ScoreLane.scoreWidth + adjustPoint.X,
* Location.Y + adjustPoint.Y,
* 20,
* 9);
* e.Graphics.DrawRectangles(myPen, new RectangleF[] { hitRect });
* }
* //*/
#endif
}
public override void Execute(SharedObjects shared)
{
int argCount = CountRemainingArgs(shared);
float vol = 1.0f;
float keyDownDuration = -1f;
if (argCount >= 5)
{
vol = (float)GetDouble(PopValueAssert(shared));
}
if (argCount >= 4)
{
keyDownDuration = (float)GetDouble(PopValueAssert(shared));
}
float duration = (float)GetDouble(PopValueAssert(shared));
object endNote = PopValueAssert(shared);
object startNote = PopValueAssert(shared);
AssertArgBottomAndConsume(shared);
if (keyDownDuration < 0)
{
keyDownDuration = duration * 0.9f; // default to 90% of the total duration, allowing a short window for the release
}
if (keyDownDuration > duration)
{
keyDownDuration = duration; // clamp keyDown to the total duration
}
if (startNote is ScalarValue)
{
ReturnValue = new NoteValue((float)GetDouble(startNote), (float)GetDouble(endNote), vol, keyDownDuration, duration);
}
else if (startNote is StringValue)
{
ReturnValue = new NoteValue(startNote.ToString(), endNote.ToString(), vol, keyDownDuration, duration);
}
else
{
ReturnValue = new NoteValue(0f, vol, keyDownDuration, duration);
}
}
public virtual async Task <List <string> > ValidateNote(NoteValue noteValue, string method)
{
var errorMessages = new List <string>();
if (IsNull(noteValue))
{
errorMessages.Add(ErrorMessages.NullObject);
return(errorMessages);
}
if (IsNullOrEmptyOrWhiteSpace(noteValue.Text))
{
errorMessages.Add(ErrorMessages.NoteEmpty);
}
if (noteValue.Text.Length > 144)
{
errorMessages.Add(ErrorMessages.NoteTextIncorrectLenght);
}
if (noteValue.DueDate != null && noteValue.DueDate < DateTime.Today)
{
errorMessages.Add(ErrorMessages.NoteDueDateLessCurrentDate);
}
if (!await _repo.IsExist <ListNote>(noteValue.ListNoteId))
{
errorMessages.Add(ErrorMessages.ListNoteNotExist);
}
if (await _repo.IsExistNoteTextInListNote(noteValue))
{
errorMessages.Add(ErrorMessages.NoteNotUnique);
}
return(errorMessages);
}
/// <summary>
/// Calculates the actual time duration, in seconds, for the given tempo that the specified
/// source note value will last. For example, if tempo is M.M. 120 quarter-notes per minute,
/// then each quarter-note would last a half-second.
/// </summary>
/// <param name="source">Source note value.</param>
/// <param name="dots">Total dotted note length extensions to apply.</param>
/// <returns>Actual duration of note value in seconds.</returns>
public double CalculateNoteValueTime(NoteValue source, int dots)
{
return m_noteValueTime * source.Duration(this.NamedNoteValue, dots);
}
/// <summary>
/// Contructs a new <see cref="Tempo"/> object.
/// </summary>
/// <param name="totalNoteValues">Total note values for <see cref="Tempo"/>.</param>
/// <param name="noteValue">Named note value used for <see cref="Tempo"/>.</param>
public Tempo(int totalNoteValues, NoteValue noteValue)
{
m_totalNoteValues = totalNoteValues;
m_noteValue = noteValue.Duration();
CalculateNoteValueTime();
}
/// <summary>
/// Validates that given note value will fit within this <see cref="MeasureSize"/> for specified beat.
/// </summary>
/// <param name="noteValue">Named note value to validate.</param>
/// <param name="beat">Beat within in measure where note value is trying to fit.</param>
/// <param name="dots">Dot length extensions to apply to named note value.</param>
public void ValidateNoteValueAtBeat(NoteValue noteValue, int beat, int dots)
{
ValidateNoteValueAtBeat(noteValue.Duration(dots), beat);
}
/// <summary>
/// Creates a new musical measure defined as the number of beats per note value.
/// </summary>
/// <param name="beats">A <see cref="Int32"/> representing the beats.</param>
/// <param name="noteValue">A <see cref="NoteValue"/> representing the note value.</param>
public MeasureSize(int beats, NoteValue noteValue)
{
m_beats = beats;
m_noteValue = noteValue.Duration();
}
/// <summary>
/// Creates a new musical measure defined as the number of beats per note value.
/// </summary>
public MeasureSize(int beats, NoteValue noteValue)
{
m_beats = beats;
m_noteValue = noteValue.Duration();
}
public void ValidateNoteValueAtBeat(NoteValue noteValue, int beat, int dots)
{
ValidateNoteValueAtBeat(noteValue.Duration(dots), beat);
}
/// <summary>
/// NoteBubble Constructor.
/// Creates a new NoteBubble object and its Note.
/// </summary>
/// <param name="noteValue">The NoteValue needed to create a Note</param>
public NoteBubble(NoteValue noteValue)
{
Note = new Note(1, noteValue, "do", -1);
Id = GlobalVariables.idNoteBubble++;
}
/// <summary>
/// Add a rest for the given length for the current beat.
/// </summary>
/// <param name="restLength">Duration of wait specified as a note value.</param>
public void AddRest(NoteValue restLength)
{
AddNotes(new Note
{
NamedValue = restLength
});
}
/// <summary>
/// Note Constructor.
/// Generates a new object of class Note, default Note
/// </summary>
public Note(NoteValue d)
{
Octave = 1;
Duration = d;
Pitch = "do";
Sharp = false;
Flat = false;
Position = -1;
}
/// <summary>
/// Add a rest for the given length for the current beat.
/// </summary>
/// <param name="restLength">Duration of wait specified as a note value.</param>
/// <param name="dots">Total dotted note length extensions to apply.</param>
public void AddRest(NoteValue restLength, int dots)
{
AddNotes(new Note
{
NamedValue = restLength, Dots = dots
});
}
/// <summary>
/// Returns source note value duration in terms of given reference note value.
/// For example, if measure size is 3/4 then reference is quarter notes and returned
/// value will be equivalent number of quarter notes for given source note.
/// </summary>
/// <param name="source">Source note value.</param>
/// <param name="reference">Reference note value.</param>
/// <param name="dots">Total dotted note length extensions to apply.</param>
/// <returns>Duration of note value in terms of specified reference note value.</returns>
public static double Duration(this NoteValue source, NoteValue reference, int dots)
{
return Duration((int)source, (int)reference, dots);
}
