private void DrawFretNumbers(int numberFrets, IGenericDrawingSurface g, int startX, int startY, ColorValue defaultCanvasFontColor)
{
for (int fretNum = 0; fretNum <= numberFrets; fretNum++)
{
int fretX = startX + GuitarString.FretNumberToClientX(fretNum, _guitarModel, 0);
if (_guitarModel.GuitarModelSettings.EnableDisplacedFingeringMarkers)
{
if (fretNum > 0)
{
var posL = fretX - GuitarString.FretNumberToClientX(fretNum - 1, _guitarModel, 0);
fretX -= posL / 2;
}
else
{
fretX -= 5; //displace 0 fret by 5
}
}
else
{
//offset x by half of text width
fretX -= ((BasicFontSizePt / 3) * fretNum.ToString().Length);
}
g.DrawString(fretX, startY + 2, fretNum.ToString(), BasicFontSizePt, defaultCanvasFontColor);
}
}
public BassGuitar()
{
s1 = new GuitarString("G");
s2 = new GuitarString("D");
s3 = new GuitarString("A");
s4 = new GuitarString("E");
}
private void WriteTrack(Track track)
{
int flags = 0;
if (track.IsPercussionTrack)
{
flags |= 0x01;
}
WriteUnsignedByte(flags);
WriteByte((byte)8);
WriteStringByte(track.Name, 40);
WriteInt(track.Strings.Count);
for (int i = 0; i < 7; i++)
{
int value = 0;
if (track.Strings.Count > i)
{
GuitarString s = track.Strings[i];
value = s.Value;
}
WriteInt(value);
}
WriteInt(1);
WriteInt(track.Channel.ChannelCode + 1);
WriteInt(track.Channel.EffectChannel + 1);
WriteInt(24);
WriteInt(track.Offset);
WriteColor(track.Color);
WriteBytes(new sbyte[]
{
67, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -1, 3, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
});
}
public StandardGuitar() : base()
{
String1.SetTuneNote("E", 4);
String2.SetTuneNote("B", 3);
String3.SetTuneNote("G", 3);
String4.SetTuneNote("D", 3);
s5 = new GuitarString("A", 2);
s6 = new GuitarString("E", 2);
}
public int GetDiagramWidth()
{
if (_guitarModel != null)
{
return(PaddingLeft
+ GuitarString.FretNumberToClientX(_guitarModel.GuitarModelSettings.NumberFrets, _guitarModel, 0)
+ PaddingRight);
}
return(0);
}
public void InitGuitarNeck()
{
int[] notes = new int[Globals.MaxStrings] {
(int)Globals._notes.NOTE_E, (int)Globals._notes.NOTE_A, (int)Globals._notes.NOTE_D, (int)Globals._notes.NOTE_G, (int)Globals._notes.NOTE_B, (int)Globals._notes.NOTE_E
};
for (int s = 0; s < Globals.MaxStrings; s++)
{
mStrings [s] = new GuitarString();
mStrings[s].InitGuitarString(s, notes[s]);
}
}
public void GuiatString_DropDTuningForString6IsCorrect()
{
// ARRANGE
var stringNumber = 6;
var tuning = "D2";
var maxFrets = 24;
var expectedCNoteIndex = 1;
// ACT
var actual = new GuitarString(stringNumber, tuning, maxFrets);
var cNoteIndex = actual.GetNote("D#2");
// ASSERT
Assert.Equal(tuning, actual.Tuning);
Assert.Equal(expectedCNoteIndex, cNoteIndex);
}
public void GuiatString_EnsureDropCSharpForString6IsCorrect()
{
// ARRANGE
var stringNumber = 6;
var tuning = "C#2";
var maxFrets = 12;
var expectedCNoteIndex = 11;
// ACT
var actual = new GuitarString(stringNumber, tuning, maxFrets);
var cNoteIndex = actual.GetNote("C3");
// ASSERT
Assert.Equal(tuning, actual.Tuning);
Assert.Equal(expectedCNoteIndex, cNoteIndex);
}
private void DrawFrets(int numberOfStrings, IGenericDrawingSurface g, int startX, int startY)
{
//draw nut
double fretLength = (_guitarModel.GuitarModelSettings.StringSpacing * (numberOfStrings));
var nutX = startX - 2;
g.DrawLine(nutX, startY + _guitarModel.GuitarModelSettings.StringSpacing, nutX, startY + fretLength, 2, ColorPalette[ThemeColorPreset.MutedForeground]);
for (int i = 0; i < _guitarModel.GuitarModelSettings.NumberFrets + 1; i++)
{
int fretTopX = startX + GuitarString.FretNumberToClientX(i, _guitarModel, 0);
int fretBottomX = startX + GuitarString.FretNumberToClientX(i, _guitarModel, _guitarModel.NumberOfStrings - 1);
int nextFretX = startX + GuitarString.FretNumberToClientX(i + 1, _guitarModel, 0);
g.DrawLine(fretTopX, startY + _guitarModel.GuitarModelSettings.StringSpacing, fretBottomX, startY + fretLength, 1, ColorPalette[ThemeColorPreset.Foreground]);
//draw fret marker at specific points
if (_guitarModel.FretsWithMarkers.Contains(i))
{
double markerLeft = fretTopX - ((nextFretX - fretTopX) / 2) - 3;
if (_guitarModel.FretMarkerStyle == FretMarkerStyle.Dots)
{
if (i % 12 == 0) //fret 12 & 24 get double marker
{
g.FillEllipse(markerLeft, startY + (_guitarModel.GuitarModelSettings.StringSpacing * numberOfStrings) - _guitarModel.GuitarModelSettings.StringSpacing, 5, 5, ColorPalette[ThemeColorPreset.Subtle], ColorPalette[ThemeColorPreset.Subtle]);
g.FillEllipse(markerLeft, startY + (_guitarModel.GuitarModelSettings.StringSpacing * 2), 5, 5, ColorPalette[ThemeColorPreset.Subtle], ColorPalette[ThemeColorPreset.Subtle]);
}
else
{
g.FillEllipse(markerLeft, startY + (_guitarModel.GuitarModelSettings.StringSpacing * (numberOfStrings / 2)) + 2, 5, 5, ColorPalette[ThemeColorPreset.Subtle], ColorPalette[ThemeColorPreset.Subtle]);
}
}
}
}
}
private void ReadNote(Note note, GuitarString guitarString, Track track)
{
/*The first byte is note flags:
*
* - *0x01*: time-independent duration
* - *0x02*: heavy accentuated note
* - *0x04*: ghost note
* - *0x08*: presence of note effects
* - *0x10*: dynamics
* - *0x20*: fret
* - *0x40*: accentuated note
* - *0x80*: right hand or left hand fingering
*
* Flags are followed by:
*
* - Note type: :ref:`byte`. Note is normal if values is 1, tied if
* value is 2, dead if value is 3.
*
* - Time-independent duration: 2 :ref:`SignedBytes <signed-byte>`.
* Correspond to duration and tuplet. See :meth:`readDuration`
* for reference.
*
* - Note dynamics: :ref:`signed-byte`. See :meth:`unpackVelocity`.
*
* - Fret number: :ref:`signed-byte`. If flag at *0x20* is set then
* read fret number.
*
* - Fingering: 2 :ref:`SignedBytes <signed-byte>`. See
* :class:`guitarpro.models.Fingering`.
*
* - Note effects. See :meth:`readNoteEffects`.*/
var flags = GpBase.ReadByte()[0];
note.Str = guitarString.Number;
note.Effect.GhostNote = ((flags & 0x04) != 0);
if ((flags & 0x20) != 0)
{
note.Type = (NoteTypes)(GpBase.ReadByte()[0]);
}
if ((flags & 0x01) != 0)
{
note.Duration = GpBase.ReadSignedByte()[0];
note.Tuplet = GpBase.ReadSignedByte()[0];
}
if ((flags & 0x10) != 0)
{
var dyn = GpBase.ReadSignedByte()[0];
note.Velocity = UnpackVelocity(dyn);
}
if ((flags & 0x20) != 0)
{
int value;
var fret = GpBase.ReadSignedByte()[0];
if (note.Type == NoteTypes.Tie)
{
value = GetTiedNoteValue(guitarString.Number, track);
}
else
{
value = fret;
}
note.Value = Math.Max(0, Math.Min(99, value));
}
if ((flags & 0x80) != 0)
{
note.Effect.LeftHandFinger = (Fingerings)GpBase.ReadSignedByte()[0];
note.Effect.RightHandFinger = (Fingerings)GpBase.ReadSignedByte()[0];
}
if ((flags & 0x08) != 0)
{
note.Effect = ReadNoteEffects(note);
if (note.Effect.IsHarmonic && note.Effect.Harmonic is TappedHarmonic)
{
note.Effect.Harmonic.Fret = note.Value + 12;
}
}
}
private void ReadTrack(Track track, MidiChannel[] channels)
{
/*
* Read track.
*
* The first byte is the track's flags. It presides the track's
* attributes:
*
* - *0x01*: drums track
* - *0x02*: 12 stringed guitar track
* - *0x04*: banjo track
* - *0x08*: *blank*
* - *0x10*: *blank*
* - *0x20*: *blank*
* - *0x40*: *blank*
* - *0x80*: *blank*
*
* Flags are followed by:
*
* - Name: :ref:`byte-size-string`. A 40 characters long string
* containing the track's name.
*
* - Number of strings: :ref:`int`. An integer equal to the number
* of strings of the track.
*
* - Tuning of the strings: List of 7 :ref:`Ints <int>`. The tuning
* of the strings is stored as a 7-integers table, the "Number of
* strings" first integers being really used. The strings are
* stored from the highest to the lowest.
*
* - Port: :ref:`int`. The number of the MIDI port used.
*
* - Channel. See :meth:`GP3File.readChannel`.
*
* - Number of frets: :ref:`int`. The number of frets of the
* instrument.
*
* - Height of the capo: :ref:`int`. The number of the fret on
* which a capo is set. If no capo is used, the value is 0.
*
* - Track's color. The track's displayed color in Guitar Pro.*/
byte flags = GpBase.ReadByte()[0];
track.IsPercussionTrack = ((flags & 0x01) != 0);
track.Is12StringedGuitarTrack = ((flags & 0x02) != 0);
track.IsBanjoTrack = ((flags & 0x04) != 0);
track.Name = GpBase.ReadByteSizeString(40);
var stringCount = GpBase.ReadInt()[0];
for (int i = 0; i < 7; i++)
{
int iTuning = GpBase.ReadInt()[0];
if (stringCount > i)
{
var oString = new GuitarString(i + 1, iTuning);
track.Strings.Add(oString);
}
}
track.Port = GpBase.ReadInt()[0];
track.Channel = ReadChannel(channels);
if (track.Channel.Channel == 9)
{
track.IsPercussionTrack = true;
}
track.FretCount = GpBase.ReadInt()[0];
track.Offset = GpBase.ReadInt()[0];
track.Color = ReadColor();
}
public Position(GuitarString stringNum, GuitarFret fretNum)
{
String = stringNum;
Fret = fretNum;
}
public string Play(int stringNumber, int atFret = 0)
{
GuitarString targetString = _guitarStrings[stringNumber];
return(targetString.Play(atFret));
}
public void DrawGuitarString(GuitarString s, int startY, int offsetX, IGenericDrawingSurface g)
{
String strNote = "";
int startX = offsetX;
//draw string
int fretboardWidth = s.GetFretboardWidth(_guitarModel, s.StringNumber);
int fanScaleMM = (int)_guitarModel.MultiScaleFanFactor;
if (_guitarModel.IsMultiScale)
{
startX += (s.StringNumber * fanScaleMM);
fretboardWidth = fretboardWidth - (s.StringNumber * fanScaleMM * 2);
}
if (_guitarModel.GuitarModelSettings.EnableDiagramStrings)
{
var stringThickness = 0.3 + ((_guitarModel.NumberOfStrings - s.StringNumber) * 0.1);
g.DrawLine(startX, startY - 0.5, startX + fretboardWidth, startY - 0.5, stringThickness, ColorPalette[ThemeColorPreset.Foreground]);
g.DrawLine(startX, startY, startX + fretboardWidth, startY, stringThickness, ColorPalette[ThemeColorPreset.MutedForeground]);
}
for (int fretNum = 0; fretNum <= _guitarModel.GuitarModelSettings.NumberFrets; fretNum++)
{
int tmpVal = fretNum + (int)s.OpenTuning.SelectedNote;
int octave = 1;
if (tmpVal > 11)
{
tmpVal = tmpVal - 12;
octave++;
}
if (tmpVal > 11)
{
tmpVal = tmpVal - 12;
octave++;
}
int sclVal = (fretNum - (int)_guitarModel.GuitarModelSettings.ScaleManager.CurrentKey) + (int)s.OpenTuning.SelectedNote;
if (sclVal < 0)
{
sclVal = sclVal + 12;
}
if (sclVal > 11)
{
sclVal = sclVal - 12;
}
if (sclVal > 11)
{
sclVal = sclVal - 12;
}
if (sclVal < 0)
{
System.Diagnostics.Debug.WriteLine(sclVal);
}
if (_guitarModel.SelectedScale.ScaleIntervals[sclVal] == true)
{
if (fretNum <= _guitarModel.GuitarModelSettings.NumberFrets)
{
ColorValue strokeColor = ColorPalette[ThemeColorPreset.Foreground];
ColorValue fillColor = ColorPalette[ThemeColorPreset.Foreground];
if (fretNum == 0)
{
//fret zero has empty circle marker
fillColor = ColorPalette[ThemeColorPreset.Subtle];
}
if ((Note)tmpVal == _guitarModel.GetKey())
{
//root note has accent colour border
strokeColor = ColorPalette[ThemeColorPreset.Accent];
}
if (_guitarModel.GuitarModelSettings.EnableDisplacedFingeringMarkers)
{
//displace marker to place behind fret
if (fretNum > 0)
{
var posL = startX - GuitarString.FretNumberToClientX(fretNum - 1, _guitarModel, s.StringNumber);
startX -= posL / 2;
startX += (_guitarModel.GuitarModelSettings.MarkerSize / 2);
}
else
{
//fret 0, displace marker behind nut
startX = startX - (_guitarModel.GuitarModelSettings.MarkerSize / 2);
}
}
var currentNote = new NoteItem
{
Note = (Note)tmpVal,
X = startX - (_guitarModel.GuitarModelSettings.MarkerSize / 2),
Y = startY - (_guitarModel.GuitarModelSettings.MarkerSize / 2),
FretNumber = fretNum,
StringNumber = s.StringNumber,
Octave = octave
};
_noteList.Add(currentNote);
if (_hightlightedNotes.Any(n => n.Note == currentNote.Note && n.StringNumber == currentNote.StringNumber && n.Octave == currentNote.Octave))
{
// highlight
g.FillEllipse(startX - (_guitarModel.GuitarModelSettings.MarkerSize / 2), startY - (_guitarModel.GuitarModelSettings.MarkerSize / 2), _guitarModel.GuitarModelSettings.MarkerSize, _guitarModel.GuitarModelSettings.MarkerSize, ColorPalette[ThemeColorPreset.MutedBackground], new ColorValue(255, 255, 255, 255));
}
//draw note marker centered behind fret
if (_guitarModel.GuitarModelSettings.EnableNoteColours == true)
{
var noteColor = NoteManager.GetNoteColour((Note)tmpVal, 2);
if (_hightlightedNotes.Any())
{
noteColor.A = 128;
}
g.FillEllipse(startX - (_guitarModel.GuitarModelSettings.MarkerSize / 2), startY - (_guitarModel.GuitarModelSettings.MarkerSize / 2), _guitarModel.GuitarModelSettings.MarkerSize, _guitarModel.GuitarModelSettings.MarkerSize, ColorPalette[ThemeColorPreset.MutedBackground], noteColor);
}
else
{
g.FillEllipse(startX - (_guitarModel.GuitarModelSettings.MarkerSize / 2), startY - (_guitarModel.GuitarModelSettings.MarkerSize / 2), _guitarModel.GuitarModelSettings.MarkerSize, _guitarModel.GuitarModelSettings.MarkerSize, fillColor, strokeColor);
}
//if enabled, draw note name/sequence number
if (_guitarModel.GuitarModelSettings.EnableDiagramNoteNames || _guitarModel.GuitarModelSettings.EnableDiagramNoteSequence || _guitarModel.GuitarModelSettings.EnableDiagramScaleIntervals)
{
if (_guitarModel.GuitarModelSettings.EnableDiagramNoteNames)
{
strNote = NoteManager.GetNoteName((Note)tmpVal, _guitarModel.GuitarModelSettings.EnableDiagramNoteNamesSharp);
}
if (_guitarModel.GuitarModelSettings.EnableDiagramNoteSequence)
{
strNote = "" + _guitarModel.GuitarModelSettings.ScaleManager.CurrentScale.GetSequenceNumberInScale(sclVal);
}
if (_guitarModel.GuitarModelSettings.EnableDiagramScaleIntervals)
{
strNote = "" + _guitarModel.GuitarModelSettings.ScaleManager.CurrentScale.GetIntervalNameInScale(sclVal);
}
double markerFontSize = BasicFontSizePt;
double labelX = startX - (_guitarModel.GuitarModelSettings.MarkerSize * 0.45);
double labelY = startY - (markerFontSize * 0.3);
if (strNote.Length == 1)
{
labelX += markerFontSize * 0.3;
g.DrawString(labelX + 0.5, labelY + 0.5, strNote, markerFontSize, ColorPalette[ThemeColorPreset.TextShadow]); //shadow
g.DrawString(labelX, labelY, strNote, markerFontSize, ColorPalette[ThemeColorPreset.ForegroundText]);
}
else
{
labelX += markerFontSize * 0.2;
labelY += markerFontSize * 0.1;
g.DrawString(labelX + 0.5, labelY + 0.5, strNote, markerFontSize * .8, ColorPalette[ThemeColorPreset.TextShadow]);
g.DrawString(labelX, labelY, strNote, markerFontSize * .8, ColorPalette[ThemeColorPreset.ForegroundText]);
}
}
}
}
startX = offsetX + GuitarString.FretNumberToClientX(fretNum + 1, _guitarModel, s.StringNumber);
}
}
public override void Render(IGenericDrawingSurface canvas)
{
if (EnableRendering == false)
{
return;
}
//select and init rendering surface type
IGenericDrawingSurface g = InitialiseDrawingSurface(canvas);
int numberOfStrings = _guitarModel.GuitarModelSettings.CurrentTuning.NumberStrings;
int numberFrets = _guitarModel.GuitarModelSettings.NumberFrets;
int startX = PaddingLeft;
int startY = PaddingTop;
_noteList = new List <NoteItem>();
ColorValue defaultCanvasFontColor = ColorPalette[ThemeColorPreset.Foreground];
int fboardWidth = GuitarString.FretNumberToClientX(_guitarModel.GuitarModelSettings.NumberFrets, _guitarModel, 0);
int fboardHeight = _guitarModel.GuitarModelSettings.StringSpacing * (numberOfStrings - 1);
if (_guitarModel.GuitarModelSettings.EnableFretboardBackgroundFill)
{
// optional background fretboard fill
g.FillRectangle(startX, startY + _guitarModel.GuitarModelSettings.StringSpacing, fboardWidth, fboardHeight, ColorPalette[ThemeColorPreset.Background], ColorPalette[ThemeColorPreset.Subtle]);
}
//draw frets..
DrawFrets(numberOfStrings, g, startX, startY);
//draw strings (and note markers)..
startY = PaddingTop + (_guitarModel.GuitarModelSettings.StringSpacing * numberOfStrings);
startY = DrawGuitarStrings(numberOfStrings, g, PaddingLeft, startY);
//draw fret numbers
if (_guitarModel.GuitarModelSettings.EnableFretNumbers)
{
startX = PaddingLeft;
startY = PaddingTop + 5 + _guitarModel.GuitarModelSettings.StringSpacing * (numberOfStrings);
DrawFretNumbers(numberFrets, g, startX, startY, defaultCanvasFontColor);
}
//show scale intervals & notes
var scale = _guitarModel.SelectedScale;
DrawScaleFormulaIntervals(g, PaddingLeft + 4, startY, scale, defaultCanvasFontColor);
DrawScaleNoteList(g, PaddingLeft + 4, startY, scale, defaultCanvasFontColor);
if (IsExportMode)
{
//draw copyright/watermark (for exported images)
g.DrawString(PaddingLeft + 5, startY + 10, "Generated by Guitar Toolkit - Copyright " + System.DateTime.Now.Year + " Soundshed.com");
}
startX = 0;
startY = 10;
//draw scale title
if (_guitarModel.GuitarModelSettings.EnableDiagramTitle)
{
var title = _guitarModel.GetDiagramTitle();
g.DrawString(startX, startY, title, 8, defaultCanvasFontColor);
}
}
public Position(GuitarString stringNum, GuitarFret fretNum)
{
String = stringNum;
Fret = fretNum;
}
