public override void DoLayout()
        {
            if (!Container.Beat.IsRest)
            {
                if (Container.Beat.BrushType != BrushType.None)
                {
                    AddGlyph(new ScoreBrushGlyph(Container.Beat));
                    AddGlyph(new SpacingGlyph(0, 0, 4 * Scale));
                }

                var accidentals = new AccidentalGroupGlyph();
                foreach (var note in Container.Beat.Notes)
                {
                    CreateAccidentalGlyph(note, accidentals);
                }

                if (!accidentals.IsEmpty)
                {
                    AddGlyph(accidentals);
                    AddGlyph(new SpacingGlyph(0, 0, 4 * (Container.Beat.GraceType != GraceType.None ? NoteHeadGlyph.GraceScale : 1) * Scale));
                }
            }

            base.DoLayout();
        }
        public override void DoLayout()
        {
            if (Container.Beat.BrushType != BrushType.None)
            {
                AddGlyph(new ScoreBrushGlyph(Container.Beat));
                AddGlyph(new SpacingGlyph(0, 0, 4 * Scale));
            }

            if (!Container.Beat.IsRest)
            {
                var accidentals = new AccidentalGroupGlyph();
                foreach (var note in Container.Beat.Notes)
                {
                    CreateAccidentalGlyph(note, accidentals);
                }

                if (!accidentals.IsEmpty)
                {
                    AddGlyph(accidentals);
                    AddGlyph(new SpacingGlyph(0, 0, 4 * (Container.Beat.GraceType != GraceType.None ? NoteHeadGlyph.GraceScale : 1) * Scale));
                }
            }

            base.DoLayout();
        }
 public BendNoteHeadGroupGlyph(Beat beat, bool showParenthesis = false)
 {
     _beat            = beat;
     _showParenthesis = showParenthesis;
     IsEmpty          = true;
     _accidentals     = new AccidentalGroupGlyph();
     _noteValueLookup = new FastDictionary <int, Glyph>();
     if (showParenthesis)
     {
         _preNoteParenthesis  = new GhostNoteContainerGlyph(true);
         _postNoteParenthesis = new GhostNoteContainerGlyph(false);
     }
 }
 private void CreateAccidentalGlyph(Note n, AccidentalGroupGlyph accidentals)
 {
     var sr = (ScoreBarRenderer)Renderer;
     var accidental = sr.AccidentalHelper.ApplyAccidental(n);
     var noteLine = sr.GetNoteLine(n);
     var isGrace = Container.Beat.GraceType != GraceType.None;
     switch (accidental)
     {
         case AccidentalType.Sharp:
             accidentals.AddGlyph(new SharpGlyph(0, sr.GetScoreY(noteLine), isGrace));
             break;
         case AccidentalType.Flat:
             accidentals.AddGlyph(new FlatGlyph(0, sr.GetScoreY(noteLine), isGrace));
             break;
         case AccidentalType.Natural:
             accidentals.AddGlyph(new NaturalizeGlyph(0, sr.GetScoreY(noteLine + 1), isGrace));
             break;
     }
 }
        private void CreateAccidentalGlyph(Note n, AccidentalGroupGlyph accidentals)
        {
            var sr         = (ScoreBarRenderer)Renderer;
            var accidental = sr.AccidentalHelper.ApplyAccidental(n);
            var noteLine   = sr.GetNoteLine(n);
            var isGrace    = Container.Beat.GraceType != GraceType.None;

            if (accidental != AccidentalType.None)
            {
                accidentals.AddGlyph(new AccidentalGlyph(0, sr.GetScoreY(noteLine), accidental, isGrace));
            }
            if (n.HarmonicType != HarmonicType.None && n.HarmonicType != HarmonicType.Natural)
            {
                var harmonicFret = n.DisplayValue + n.HarmonicPitch;
                accidental = sr.AccidentalHelper.ApplyAccidentalForValue(n.Beat, harmonicFret, isGrace);
                noteLine   = sr.AccidentalHelper.GetNoteLineForValue(harmonicFret);
                accidentals.AddGlyph(new AccidentalGlyph(0, sr.GetScoreY(noteLine), accidental, isGrace));
            }
        }
Example #6
0
        public override void DoLayout()
        {
            if (Container.Beat.BrushType != BrushType.None)
            {
                AddGlyph(new ScoreBrushGlyph(Container.Beat));
                AddGlyph(new SpacingGlyph(0, 0, 4 * Scale));
            }

            if (!Container.Beat.IsRest && !Container.Beat.Voice.Bar.Track.IsPercussion)
            {
                var accidentals = new AccidentalGroupGlyph();
                NoteLoop(n => CreateAccidentalGlyph(n, accidentals));
                AddGlyph(accidentals);
            }

            // a small padding
            AddGlyph(new SpacingGlyph(0, 0, 4 * (Container.Beat.GraceType != GraceType.None ? NoteHeadGlyph.GraceScale : 1) * Scale));

            base.DoLayout();
        }
        public override void DoLayout()
        {
            if (Container.Beat.BrushType != BrushType.None)
            {
                AddGlyph(new ScoreBrushGlyph(Container.Beat));
                AddGlyph(new SpacingGlyph(0, 0, 4 * Scale));
            }

            if (!Container.Beat.IsRest && !Container.Beat.Voice.Bar.Track.IsPercussion)
            {
                var accidentals = new AccidentalGroupGlyph();
                NoteLoop(n => CreateAccidentalGlyph(n, accidentals));
                AddGlyph(accidentals);
            }

            // a small padding
            AddGlyph(new SpacingGlyph(0, 0, 4 * (Container.Beat.GraceType != GraceType.None ? NoteHeadGlyph.GraceScale : 1) * Scale));

            base.DoLayout();
        }
Example #8
0
        private void CreateAccidentalGlyph(Note n, AccidentalGroupGlyph accidentals)
        {
            var sr         = (ScoreBarRenderer)Renderer;
            var noteLine   = sr.GetNoteLine(n);
            var accidental = sr.AccidentalHelper.ApplyAccidental(n, noteLine);
            var isGrace    = Container.Beat.GraceType != GraceType.None;

            switch (accidental)
            {
            case AccidentalType.Sharp:
                accidentals.AddGlyph(new SharpGlyph(0, sr.GetScoreY(noteLine), isGrace));
                break;

            case AccidentalType.Flat:
                accidentals.AddGlyph(new FlatGlyph(0, sr.GetScoreY(noteLine), isGrace));
                break;

            case AccidentalType.Natural:
                accidentals.AddGlyph(new NaturalizeGlyph(0, sr.GetScoreY(noteLine + 1), isGrace));
                break;
            }
        }
        public override void DoLayout()
        {
            if (!Container.Beat.IsRest)
            {
                var accidentals = new AccidentalGroupGlyph();
                var ghost       = new GhostNoteContainerGlyph(true);
                ghost.Renderer     = Renderer;
                _prebends          = new BendNoteHeadGroupGlyph(Container.Beat, true);
                _prebends.Renderer = Renderer;
                foreach (var note in Container.Beat.Notes)
                {
                    if (note.IsVisible)
                    {
                        if (note.HasBend)
                        {
                            switch (note.BendType)
                            {
                            case BendType.PrebendBend:
                            case BendType.Prebend:
                            case BendType.PrebendRelease:
                                _prebends.AddGlyph(note.DisplayValue - note.BendPoints[0].Value / 2);
                                break;
                            }
                        }
                        else if (note.Beat.HasWhammyBar)
                        {
                            switch (note.Beat.WhammyBarType)
                            {
                            case WhammyType.PrediveDive:
                            case WhammyType.Predive:
                                _prebends.AddGlyph(note.DisplayValue - note.Beat.WhammyBarPoints[0].Value / 2);
                                break;
                            }
                        }

                        CreateAccidentalGlyph(note, accidentals);
                        ghost.AddParenthesis(note);
                    }
                }

                if (!_prebends.IsEmpty)
                {
                    AddGlyph(_prebends);
                    AddGlyph(new SpacingGlyph(0, 0, 4 * (Container.Beat.GraceType != GraceType.None ? NoteHeadGlyph.GraceScale : 1) * Scale));
                }

                if (Container.Beat.BrushType != BrushType.None)
                {
                    AddGlyph(new ScoreBrushGlyph(Container.Beat));
                    AddGlyph(new SpacingGlyph(0, 0, 4 * Scale));
                }

                if (!ghost.IsEmpty)
                {
                    AddGlyph(ghost);
                    AddGlyph(new SpacingGlyph(0, 0, 4 * (Container.Beat.GraceType != GraceType.None ? NoteHeadGlyph.GraceScale : 1) * Scale));
                }

                if (!accidentals.IsEmpty)
                {
                    AddGlyph(accidentals);
                    AddGlyph(new SpacingGlyph(0, 0, 4 * (Container.Beat.GraceType != GraceType.None ? NoteHeadGlyph.GraceScale : 1) * Scale));
                }
            }

            base.DoLayout();
        }