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);
}
}
private void DrawScaleNoteList(IGenericDrawingSurface g, int offsetX, int startY, ScaleItem scale, ColorValue fontColor)
{
string scaleNotes = "";
int notePos = 0;
try
{
for (int i = 0; i < scale.ScaleIntervals.Length; i++)
{
if (scale.ScaleIntervals[i])
{
notePos++;
scaleNotes += NoteManager.GetNoteName(scale.GetNoteAtSequencePosition(notePos, NoteManager.GetNoteByName(_guitarModel.SelectedKey)), true);
scaleNotes += " ";
}
}
}
catch (Exception)
{
System.Diagnostics.Debug.WriteLine("Exception: Couldn't resolve note name at one or more scale position");
}
g.DrawString(offsetX + 2, startY + 18, "Notes:", BasicFontSizePt, fontColor);
g.DrawString(offsetX + 40, startY + 18, scaleNotes, BasicFontSizePt, fontColor);
}
private void DrawScaleFormulaIntervals(IGenericDrawingSurface g, int offsetX, int startY, ScaleItem scale, ColorValue fontColor)
{
string scaleIntervals = _guitarModel.GetScaleIntervals();
g.DrawString(offsetX + 2, startY + 11, "Intervals:", BasicFontSizePt, fontColor);
g.DrawString(offsetX + 40, startY + 11, scaleIntervals, BasicFontSizePt, fontColor);
}
private double DrawFrettedNote(IGenericDrawingSurface g, int numString, int timePos, int numFret, Note note, double previousNoteXPos, double groupNoteSpacing)
{
double vspacing = 3;
//calc position of this note, based on end of previous note
double xNotePos = measureX + groupNoteSpacing;
double noteDisplayWidth = GetNoteDisplayWidth(note, groupNoteSpacing);
//if previous note drawn in measure, start from there
if (previousNoteXPos > measureX)
{
xNotePos = previousNoteXPos;
}
double yNotePos = (measureY + (numString * stringSpacing));// -(fontSize * 0.5);
//draw masking rectangle behind text to improve readability
double notationWidth = (numFret.ToString().Length *(fontSize * 0.75));
g.FillRectangle(xNotePos, yNotePos + (fontSize * 0.5), notationWidth, (fontSize), ColorPreset.Background, ColorPreset.Background);
//draw fret number on string
g.DrawString(xNotePos, yNotePos + (fontSize * 0.5), numFret.ToString(), fontSize);
//draw notations
if (note.Notations != null)
{
//draw slur start
if (note.Notations.IsSlurStart)
{
g.DrawArc(xNotePos + vspacing, yNotePos - vspacing, groupNoteSpacing, true);
}
if (note.Notations.IsSlideStart)
{
g.DrawLine((xNotePos + fontSize), (yNotePos + fontSize), (xNotePos + groupNoteSpacing), (yNotePos + fontSize), 2, ColorPreset.Foreground);
}
if (note.Notations.Technical.IsVibrato)
{
double x1 = xNotePos + vspacing;
double y1 = measureY - STANDARD_STRINGSPACING;
string vibratoString = "~";
for (int i = 0; i < note.Duration; i++)
{
vibratoString += "~";
}
g.DrawString(x1, y1, vibratoString, STANDARD_FONTSIZE * 2);
}
}
xNotePos += noteDisplayWidth;
return(xNotePos);
}
private int DrawGuitarStrings(int numberOfStrings, IGenericDrawingSurface g, int offsetX, int startY)
{
for (int i = 0; i < numberOfStrings; i++)
{
DrawGuitarString(_guitarModel.GuitarStrings[i], startY, offsetX, g);
startY = startY - _guitarModel.GuitarModelSettings.StringSpacing;
}
return(startY);
}
private void DrawRest(IGenericDrawingSurface g, int timePos, Note note)
{
int leftPadding = 4;
double xRestPos = leftPadding + (measureX + ((timePos - 1) * noteSpacing));
double yRestPos = 30;
g.DrawString(xRestPos, yRestPos, "r");
if (note.IsDotted)
{
g.DrawString(xRestPos + 10, yRestPos, "dotted");
}
}
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]);
}
}
}
}
}
public void Render(object canvas, double canvasMaxWidth)
{
#region Initialise Canvas
InitialiseRenderingSettings();
//select and init rendering surface type
IGenericDrawingSurface g = null;
#if NETFX_CORE
if (canvas is Canvas)
{
g = new WPFDrawingSurface((Canvas)canvas);
((Canvas)canvas).Width = 864;
((Canvas)canvas).Height = 12000;
foreach (GenericColorPreset p in ColorOverrides)
{
((WPFDrawingSurface)g).OveridePresetColor(p);
}
}
#endif
#if DESKTOP
if (canvas is System.Windows.Controls.Canvas)
{
g = new WPFDrawingSurface((System.Windows.Controls.Canvas)canvas);
((System.Windows.Controls.Canvas)canvas).Width = 1024;
((System.Windows.Controls.Canvas)canvas).Height = 12000;
foreach (GenericColorPreset p in ColorOverrides)
{
((WPFDrawingSurface)g).OveridePresetColor(p);
}
}
#endif
#if !SILVERLIGHT && !NETFX_CORE
if (canvas is Graphics)
{
((Graphics)canvas).CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
g = new GDIDrawingSurface((Graphics)canvas);
}
if (canvas is PdfSharp.Pdf.PdfDocument)
{
// ((Graphics)canvas).CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
g = new PDFDrawingSurface((PdfSharp.Pdf.PdfDocument)canvas);
((PDFDrawingSurface)g).RequestNewPage = true;
noteSpacing = 12;
}
if (canvas is WebDrawingSurface)
{
g = (WebDrawingSurface)canvas;
}
#endif
g.Clear();
#endregion
//init score part selection if not already set
if (SelectedPartID == "" || SelectedPartID == null)
{
SelectDefaultPart();
}
startX = marginX;
startY = marginY;
// draw song tablature
if (this.score != null)
{
#region render document titles
if (score.IsLoadedCorrectly == false || SelectedPartID == null)
{
g.DrawString(10, 10, "File did not load completely.", 14, ColorPreset.Subtle);
if (SelectedPartID == null)
{
System.Diagnostics.Debug.WriteLine("Could not render any parts");
return;
}
}
//song title (centered,large)
//g.DrawStringCentered(startY, score.Title, canvasMaxWidth, 20);
g.DrawString(startX, startY, score.Title, 20);
startY += 28;
//artist
g.DrawString(startX, startY, score.Artist, 12);
startY += 18;
//album
g.DrawString(startX, startY, score.Album, 12);
startY += 18;
//words and music
//
if (score.Author.Length > 0)
{
//g.DrawStringCentered(startY, "Words & Music " + score.Author, canvasMaxWidth, 9);
g.DrawString(startX, startY, "Words & Music " + score.Author, 9);
startY += 18;
}
//part name
g.DrawString(startX, startY, "Part: " + score.GetPartName(SelectedPartID), 9);
//begin rendering score
startY += 36;
xPos = startX;
yPos = startY;
beatPos = 0;
measuresDrawn = 0;
//layout rules:
//1: at 8 notes per measure a standard number of measures will fit onscreen (4)
//2: measures are precalculated in width up to the end of the current row, this then decides the note spacing factor for the row relative
//3: the measures for this row are then drawn and a new row starts
//max measures per displayed row is calculated as max number of standard measures which can fit in the canvas width
//int maxMeasuresPerRow = (int)Math.Round(canvasMaxWidth / (noteSpacing * standardMeasureDivisions));
//if (maxMeasuresPerRow > 6) maxMeasuresPerRow = 6;
canvasMaxWidth = GetNoteDisplayWidth(1, NoteType.Eighth, noteSpacing) * standardMeasureDivisions * StandardMeasuresPerRow;
//int totalScoreWidth = stdMeasuresPerRow * ((int)noteSpacing * standardMeasureDivisions);
standardMeasureWidth = (int)noteSpacing * standardMeasureDivisions;
//TODO: need layout pass to calculate measure sizes? check tuxguitar source to see examples.
measureY = 0;
measureX = 0;
int measureCount = 0;
//Measure track pairs are stuctured Measure 1, Track 1, Measure 1, Track 2, Measure 2, Track 1 etc
string trackID = SelectedPartID;
if (trackID == null)
{
g.DrawStringCentered(50, "No score loaded", canvasMaxWidth, 12);
return;
}
#endregion
if (score.HasPart(trackID))
{
#region render score measures for selected part (track)
int measureNum = score.GetPartMeasureCount(trackID);
double scoreRightX = 0;
nextNoteXPos = measureX;
//initialise measure display spacing
ArrangeMeasureDisplayGroups(score.Parts[trackID].Measures, canvasMaxWidth);
int measureGroup = 0;
for (int m = 0; m < score.Parts[trackID].Measures.Count; m++)
{
Measure measure = score.Parts[trackID].Measures[m];
numStrings = score.Parts[trackID].ScoreInstrument.NumStrings;
double measureEndX = 0;
#if DEBUG
//System.Diagnostics.Debug.WriteLine("Measure:" + m + " group:" + measure._DisplayMeasureGroup + " spacing: " + measure._DisplayNoteSpacing + " : width:" + measure._DisplayWidth);
//System.Diagnostics.Debug.WriteLine(measure.ToString());
#endif
noteSpacing = measure._DisplayNoteSpacing;
if (measureGroup == measure._DisplayMeasureGroup)
{
measureX = nextNoteXPos;// +measure._DisplayNoteSpacing;
measureY = startY + (numRows * numStrings * stringSpacing);
beatPos = 0;
}
else
{
measureGroup++;
StartNextMeasureRow(measure._DisplayNoteSpacing);
beatPos = 0;
}
nextNoteXPos = measureX;
if (measuresDrawn == 0)
{
measureX = xPos;
//Draw strings
int stringy = 0;
scoreRightX = xPos + canvasMaxWidth; //measureX + scoreWidth;//(standardMeasureLength * stdMeasuresPerRow);
for (int i = 0; i < numStrings; i++)
{
g.DrawLine(measureX, measureY + stringy, scoreRightX, measureY + stringy, 1, ColorPreset.Foreground);
stringy += stringSpacing;
}
//draw bar decoration
//left
if (numRows == 0)
{
g.DrawLine(measureX, measureY, measureX, measureY + ((numStrings - 1) * stringSpacing), 3, ColorPreset.Foreground);
g.DrawLine(measureX + 3, measureY, measureX + 3, measureY + ((numStrings - 1) * stringSpacing), 1, ColorPreset.Foreground);
}
else
{
g.DrawLine(measureX, measureY, measureX, measureY + ((numStrings - 1) * stringSpacing), 1, ColorPreset.Foreground);
}
//right
g.DrawLine(scoreRightX, measureY, scoreRightX, measureY + ((numStrings - 1) * stringSpacing), 1, ColorPreset.Foreground);
//draw tempo: TODO: get tempo from first measure if not specified
if (measure.Sound != null)
{
if (measure.Sound.Tempo != null)
{
g.DrawString(measureX + 36, measureY - (STANDARD_STRINGSPACING * 2), "t = " + measure.Sound.Tempo.ToString(), fontSize);
}
}
//draw measure number
g.DrawString(measureX, measureY - (STANDARD_STRINGSPACING * 2), (measureCount + 1).ToString(), fontSize, ColorPreset.Accent);
}
else
{
g.DrawLine(measureX, measureY, measureX, measureY + ((numStrings - 1) * stringSpacing), 1, ColorPreset.Foreground);
}
measuresDrawn++;
//render notes in measure
bool measureIsRest = true;
nextNoteXPos = measureX;
double previousNoteXEndPos = 0;
double previousNoteWidth = 0;
//bool isPreviousNoteAChord =false;
for (int noteNum = 0; noteNum < measure.Notes.Count; noteNum++)
{
Note note = measure.Notes[noteNum];
if (!note.IsChordNote)
{
beatPos++;
nextNoteXPos = previousNoteXEndPos;
}
else
{
//jump back to chord start pos for rest of chord notes
nextNoteXPos = nextNoteXPos - previousNoteWidth;
}
if (!note.IsRest)
{
int stringNum = note.Notations.Technical.String;
int fretNum = note.Notations.Technical.Fret;
//System.Diagnostics.Debug.WriteLine("note xpos:"+nextNoteXPos);
previousNoteXEndPos = DrawFrettedNote(g, stringNum - 1, beatPos, fretNum, note, nextNoteXPos, measure._DisplayNoteSpacing);
previousNoteWidth = previousNoteXEndPos - nextNoteXPos;
nextNoteXPos = previousNoteXEndPos;
measureIsRest = false;
}
else
{
if (note.Duration < 4)
{
DrawRest(g, beatPos, note);
}
//rest
nextNoteXPos += GetNoteDisplayWidth(note, measure._DisplayNoteSpacing);
beatPos += standardMeasureDivisions;
}
//if (note.IsChordNote) isPreviousNoteAChord = true;
}
if (measureIsRest)
{
//draw bar rest
g.DrawLine(measureX + 20, measureY + 20, measureX + 40, measureY + 20, 6, ColorPreset.Foreground);
nextNoteXPos += 4 * (int)noteSpacing;; //standardMeasureDivisions * (int)noteSpacing;
}
//if beatPos is less than division (so less than 8 notes rendered, advance beatpos)
if (beatPos < standardMeasureDivisions)
{
beatPos = standardMeasureDivisions;
}
measureEndX = measureX + measure._DisplayWidth; //nextNoteXPos;
//draw end of measure
// g.DrawLine(measureEndX, measureY, measureEndX, measureY + ((numStrings - 1) * stringSpacing), 1, Color.Black.ToString());
measureCount++;
}
#endregion
}
#if !SILVERLIGHT && !NETFX_CORE
//update scroll region
this.ScrollWindow = new System.Drawing.Size(0, startY + ((numRows + 1) * numStrings * stringSpacing));
#endif
}
}
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 override void Render(IGenericDrawingSurface canvas)
{
if (EnableRendering == false)
{
return;
}
if (CurrentChordDiagrams == null)
{
return;
}
DrawingColor = ColorPalette[ThemeColorPreset.Foreground];
BackgroundColor = ColorPalette[ThemeColorPreset.Background];
IGenericDrawingSurface g = InitialiseDrawingSurface(canvas, 800, 1024);
int startX = GENERAL_PADDING;
int startY = GENERAL_PADDING;
int stringSpacing = STRING_SPACING;
int fretSpacing = FRET_SPACING;
int fretMarkerSize = FRET_MARKERSIZE;
int numFrets = NUMBER_OF_FRETS;
int fontSize = FONT_SIZE;
int fretBoardWidth = (stringSpacing * (GuitarModel.NumberOfStrings - 1));
int minFretboardBoxSize = (stringSpacing * 5); //allow min fretboard spacing of 6 strings width
int chordsPerRow = ChordsPerRow;
int rowY = startY;
int titleSpacing = fontSize * 2;
int rowChordCount = 0;
int xPos, yPos;
foreach (ChordDiagram CurrentChordDiagram in CurrentChordDiagrams)
{
if (rowChordCount >= chordsPerRow)
{
//start new row
rowY += (titleSpacing * 2) + (numFrets * fretSpacing);
xPos = startX;
yPos = rowY;
rowChordCount = 0;
}
else
{
//start next chord on same row
if (rowChordCount > 0)
{
//next chord position in row is based on fretboardwidth +padding
xPos = startX +
(rowChordCount *
(fretBoardWidth < minFretboardBoxSize ? minFretboardBoxSize : fretBoardWidth) + (rowChordCount * stringSpacing)
);
//+ (rowChordCount * stringSpacing) + stringSpacing;
}
else
{
xPos = startX;
}
yPos = rowY;
}
//draw chord name
g.DrawString(xPos, yPos, CurrentChordDiagram.ChordName, fontSize, DrawingColor);
yPos += fontSize * 2;
//draw nut (if chord starts at fret 0)
g.DrawLine(xPos, yPos, xPos + fretBoardWidth, yPos, 2D, DrawingColor);
//draw strings
for (int i = 0; i < GuitarModel.NumberOfStrings; i++)
{
double currentX = xPos + (i * stringSpacing);
g.DrawLine(currentX, yPos, currentX, yPos + (numFrets * fretSpacing), 1, DrawingColor);
}
//draw frets
for (int i = 0; i <= numFrets; i++)
{
double currentY = yPos + (i * fretSpacing);
g.DrawLine(xPos, currentY, xPos + fretBoardWidth, currentY, 1, DrawingColor);
}
//draw fretted notes per string
for (int i = 0; i < GuitarModel.NumberOfStrings; i++)
{
double currentX = xPos + (i * stringSpacing) - (fretMarkerSize / 2); //position marker centred on string
if (CurrentChordDiagram.FrettedStrings[i] != null)
{
int fret = CurrentChordDiagram.FrettedStrings[i].Fret;
double currentY = yPos + (fret * fretSpacing) - (fretSpacing / 2) - (fretMarkerSize / 2); //position marker centered between frets or behind nut
if (fret == 0)
{
g.FillEllipse(currentX, currentY, fretMarkerSize, fretMarkerSize, ColorPalette[ThemeColorPreset.MutedForeground], DrawingColor);
}
else
{
g.FillEllipse(currentX, currentY, fretMarkerSize, fretMarkerSize, DrawingColor, DrawingColor);
}
}
else
{
//string not played
g.DrawString(currentX, yPos - (fretSpacing / 2) - (fretMarkerSize / 2), "x", DrawingColor);
}
}
rowChordCount++; //move to next chord in list
}
}
public int GetRequiredHeight(IGenericDrawingSurface canvas)
{
return(1024 * 3);
}
public virtual void Render(IGenericDrawingSurface canvas)
{
throw new NotImplementedException();
}
public IGenericDrawingSurface InitialiseDrawingSurface(IGenericDrawingSurface canvas, double?width = null, double?height = null)
{
IGenericDrawingSurface g = canvas;
return(g);
}
