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);
 }
Example #13
0
 public virtual void Render(IGenericDrawingSurface canvas)
 {
     throw new NotImplementedException();
 }
Example #14
0
        public IGenericDrawingSurface InitialiseDrawingSurface(IGenericDrawingSurface canvas, double?width = null, double?height = null)
        {
            IGenericDrawingSurface g = canvas;

            return(g);
        }