Пример #1
0
        /// <summary>
        /// Writes out an SVG Voice
        /// </summary>
        /// <param name="w"></param>
        public virtual void WriteSVG(SvgWriter w, bool staffIsVisible)
        {
            for (int i = 0; i < NoteObjects.Count; ++i)
            {
                NoteObject noteObject = NoteObjects[i];
                Barline    barline    = noteObject as Barline;
                if (staffIsVisible && barline != null)
                {
                    bool       isLastNoteObject = (i == (NoteObjects.Count - 1));
                    float      top                  = Staff.Metrics.StafflinesTop;
                    float      bottom               = Staff.Metrics.StafflinesBottom;
                    PageFormat pageFormat           = Staff.SVGSystem.Score.PageFormat;
                    float      barlineStrokeWidth   = pageFormat.BarlineStrokeWidth;
                    float      stafflineStrokeWidth = pageFormat.StafflineStemStrokeWidth;
                    barline.WriteSVG(w, top, bottom, barlineStrokeWidth, stafflineStrokeWidth, isLastNoteObject, false);
                }

                ChordSymbol chordSymbol = noteObject as ChordSymbol;
                if (chordSymbol != null)
                {
                    chordSymbol.WriteSVG(w, staffIsVisible);
                }
                else
                {
                    // if this is the first barline, the staff name and (maybe) barnumber will be written.
                    noteObject.WriteSVG(w, staffIsVisible);
                }
            }
        }
Пример #2
0
 public void Add(NoteObject noteObject)
 {
     if (noteObject is DurationSymbol durationSymbol)
     {
         M.Assert(_absMsPosition == durationSymbol.AbsMsPosition);
     }
     _noteObjects.Add(noteObject);
 }
Пример #3
0
        public void Add(NoteObject noteObject)
        {
            DurationSymbol durationSymbol = noteObject as DurationSymbol;

            if (durationSymbol != null && _msPosition != durationSymbol.MsPosition)
            {
                throw new InvalidOperationException("Attempt to add a non-synchronous DurationSymbol to a MomentSymbol.");
            }
            _noteObjects.Add(noteObject);
        }
Пример #4
0
        /// <summary>
        /// There is still one system per bar.
        /// Each VoiceDef begins with an MNXCommon.Clef (taking small clefs into account).
        /// An Exception will be thrown if a SmallClefDef is found on the lower voiceDef in a staff in the systems input.
        /// Small clefs (if there are any) are copied from the top to the bottom voice (if there is one) on each staff.
        /// Small clefs on lower voices on a staff have IsVisible set to false.
        /// </summary>
        /// <param name="systems"></param>
        public void ConvertVoiceDefsToNoteObjects(List <SvgSystem> systems)
        {
            byte[] currentChannelVelocities = new byte[systems[0].Staves.Count];
            var    topVoiceSmallClefs       = new List <SmallClef>();

            int systemAbsMsPos = 0;

            for (int systemIndex = 0; systemIndex < systems.Count; ++systemIndex)
            {
                SvgSystem system = systems[systemIndex];
                system.AbsStartMsPosition = systemAbsMsPos;
                int msPositionReVoiceDef = 0;
                for (int staffIndex = 0; staffIndex < system.Staves.Count; ++staffIndex)
                {
                    Staff staff = system.Staves[staffIndex];
                    msPositionReVoiceDef = 0;
                    topVoiceSmallClefs.Clear();
                    for (int voiceIndex = 0; voiceIndex < staff.Voices.Count; ++voiceIndex)
                    {
                        Voice voice = staff.Voices[voiceIndex];
                        voice.VoiceDef.AgglomerateRests();

                        msPositionReVoiceDef = 0;
                        List <IUniqueDef> iuds = voice.VoiceDef.UniqueDefs;
                        M.Assert(iuds[0] is ClefDef || iuds[0] is MNX.Common.Clef); /** <-------------- **/

                        for (int iudIndex = 0; iudIndex < iuds.Count; ++iudIndex)
                        {
                            IUniqueDef iud           = voice.VoiceDef.UniqueDefs[iudIndex];
                            int        absMsPosition = systemAbsMsPos + msPositionReVoiceDef;

                            NoteObject noteObject =
                                SymbolSet.GetNoteObject(voice, absMsPosition, iud, iudIndex, ref currentChannelVelocities[staffIndex]);

                            if (noteObject is SmallClef smallClef)
                            {
                                if (voiceIndex == 0)
                                {
                                    if (staff.Voices.Count > 1)
                                    {
                                        topVoiceSmallClefs.Add(smallClef);
                                    }
                                }
                                else
                                {
                                    throw new Exception("SmallClefs may not be defined for a lower voice. They will be copied from the top voice");
                                }
                            }

                            if (iud is IUniqueSplittableChordDef iscd && iscd.MsDurationToNextBarline != null)
                            {
                                msPositionReVoiceDef += (int)iscd.MsDurationToNextBarline;
                            }
Пример #5
0
        private void AddNoteObject(NoteObject noteObject)
        {
            DurationSymbol durationSymbol = noteObject as DurationSymbol;

            if (durationSymbol != null && _noteObjects.Count > 0)
            {
                Debug.Assert(durationSymbol.MsPosition == _msPosition);
                Debug.Assert(durationSymbol.Voice.Staff == _noteObjects[0].Voice.Staff);
            }

            _noteObjects.Add(noteObject);
        }
Пример #6
0
        /// <summary>
        /// returns
        /// -1 if metrics is entirely to the left of the fixedNoteObject;
        /// 0 if metrics overlaps the fixedNoteObject;
        /// 1 if metrics is entirely to the right of the fixedNoteObject;
        /// </summary>
        /// <returns></returns>
        private int OverlapsHorizontally(Metrics metrics, NoteObject fixedNoteObject)
        {
            int     rval         = 0;
            Metrics fixedMetrics = fixedNoteObject.Metrics;

            if (metrics.Right < fixedMetrics.Left)
            {
                rval = -1;
            }
            else if (metrics.Left > fixedMetrics.Right)
            {
                rval = 1;
            }
            return(rval);
        }
Пример #7
0
        public override NoteObject GetNoteObject(Voice voice, IUniqueDef iud, bool firstDefInVoice,
                                                 ref byte currentVelocity, float musicFontHeight)
        {
            NoteObject         noteObject         = null;
            CautionaryChordDef cautionaryChordDef = iud as CautionaryChordDef;
            MidiChordDef       midiChordDef       = iud as MidiChordDef;
            InputChordDef      inputChordDef      = iud as InputChordDef;
            RestDef            restDef            = iud as RestDef;
            ClefChangeDef      clefChangeDef      = iud as ClefChangeDef;

            PageFormat pageFormat              = voice.Staff.SVGSystem.Score.PageFormat;
            float      cautionaryFontHeight    = pageFormat.CautionaryNoteheadsFontHeight;
            int        minimumCrotchetDuration = pageFormat.MinimumCrotchetDuration;

            if (cautionaryChordDef != null && firstDefInVoice)
            {
                CautionaryChordSymbol cautionaryChordSymbol = new CautionaryChordSymbol(voice, cautionaryChordDef, cautionaryFontHeight);
                noteObject = cautionaryChordSymbol;
            }
            else if (midiChordDef != null)
            {
                OutputChordSymbol outputChordSymbol = new OutputChordSymbol(voice, midiChordDef, minimumCrotchetDuration, musicFontHeight);

                if (midiChordDef.MidiVelocity != currentVelocity)
                {
                    outputChordSymbol.AddDynamic(midiChordDef.MidiVelocity, currentVelocity);
                    currentVelocity = midiChordDef.MidiVelocity;
                }
                noteObject = outputChordSymbol;
            }
            else if (inputChordDef != null)
            {
                InputChordSymbol inputChordSymbol = new InputChordSymbol(voice, inputChordDef, minimumCrotchetDuration, musicFontHeight);
                noteObject = inputChordSymbol;
            }
            else if (restDef != null)
            {
                RestSymbol restSymbol = new RestSymbol(voice, iud, minimumCrotchetDuration, musicFontHeight);
                noteObject = restSymbol;
            }
            else if (clefChangeDef != null)
            {
                ClefChangeSymbol clefChangeSymbol = new ClefChangeSymbol(voice, clefChangeDef.ClefType, cautionaryFontHeight, ((IUniqueDef)iud).MsPosition);
                noteObject = clefChangeSymbol;
            }

            return(noteObject);
        }
Пример #8
0
        /// <summary>
        /// Returns the first chordSymbol or restSymbol after the first cautionaryChordSymbol.
        /// If there are cautionaryChordSymbols between the first and the returned chordSymbol or restSymbol, they are rendered invisible.
        /// If there is a barline immediately preceding the durationSymbol that would otherwise be returned, the barline is returned.
        /// Null is returned if no further chordSymbol or RestSymbol is found in the noteObjects.
        /// </summary>
        /// <param name="noteObjects"></param>
        /// <returns></returns>
        private NoteObject GetFollowingChordRestOrBarlineSymbol(List <NoteObject> noteObjects)
        {
            NoteObject noteObjectToReturn = null;
            bool       firstCautionaryChordSymbolFound = false;

            for (int i = 0; i < noteObjects.Count; ++i)
            {
                NoteObject noteObject = noteObjects[i];
                if (firstCautionaryChordSymbolFound == false && noteObject is CautionaryChordSymbol)
                {
                    firstCautionaryChordSymbolFound = true;
                    continue;
                }

                if (firstCautionaryChordSymbolFound)
                {
                    CautionaryChordSymbol followingCautionary = noteObject as CautionaryChordSymbol;
                    if (followingCautionary != null)
                    {
                        followingCautionary.Visible = false;
                        continue;
                    }

                    if (noteObject is ChordSymbol)
                    {
                        noteObjectToReturn = noteObject;
                    }

                    if (noteObject is RestSymbol)
                    {
                        noteObjectToReturn = noteObject;
                    }
                }

                if (noteObjectToReturn != null) // a ChordSymbol or a RestSymbol (not a CautionaryChordSymbol)
                {
                    Barline barline = noteObjects[i - 1] as Barline;
                    if (barline != null)
                    {
                        noteObjectToReturn = barline;
                    }
                    break;
                }
            }
            return(noteObjectToReturn);
        }
Пример #9
0
        /// <summary>
        /// Move paddedMetrics above the fixedNoteObject if it is not already.
        /// </summary>
        private void MovePaddedMetricsAboveNoteObject(PaddedMetrics paddedMetrics, NoteObject fixedNoteObject)
        {
            double verticalOverlap = 0;

            if (fixedNoteObject.Metrics is ChordMetrics chordMetrics)
            {
                verticalOverlap = chordMetrics.OverlapHeight(paddedMetrics, 0F);
            }
            else if (fixedNoteObject.Metrics is RestMetrics restMetrics)
            {
                verticalOverlap = restMetrics.OverlapHeight(paddedMetrics, 0F);
            }
            else if (!(fixedNoteObject is Barline))
            {
                verticalOverlap = fixedNoteObject.Metrics.OverlapHeight(paddedMetrics, 0F);
            }

            if (verticalOverlap > 0)
            {
                verticalOverlap = (verticalOverlap > paddedMetrics.BottomPadding) ? verticalOverlap : paddedMetrics.BottomPadding;
                paddedMetrics.Move(0, -verticalOverlap);
            }
        }
Пример #10
0
        public override Metrics NoteObjectMetrics(Graphics graphics, NoteObject noteObject, VerticalDir voiceStemDirection, float gap, float strokeWidth)
        {
            Metrics               returnMetrics         = null;
            ClefSymbol            clef                  = noteObject as ClefSymbol;
            Barline               barline               = noteObject as Barline;
            CautionaryChordSymbol cautionaryChordSymbol = noteObject as CautionaryChordSymbol;
            ChordSymbol           chord                 = noteObject as ChordSymbol;
            RestSymbol            rest                  = noteObject as RestSymbol;

            if (barline != null)
            {
                returnMetrics = new BarlineMetrics(graphics, barline, gap);
            }
            else if (clef != null)
            {
                if (clef.ClefType != "n")
                {
                    returnMetrics = new ClefMetrics(clef, gap);
                }
            }
            else if (cautionaryChordSymbol != null)
            {
                returnMetrics = new ChordMetrics(graphics, cautionaryChordSymbol, voiceStemDirection, gap, strokeWidth);
            }
            else if (chord != null)
            {
                returnMetrics = new ChordMetrics(graphics, chord, voiceStemDirection, gap, strokeWidth);
            }
            else if (rest != null)
            {
                // All rests are originally created on the centre line.
                // They are moved vertically later, if they are on a 2-Voice staff.
                returnMetrics = new RestMetrics(graphics, rest, gap, noteObject.Voice.Staff.NumberOfStafflines, strokeWidth);
            }

            return(returnMetrics);
        }
Пример #11
0
        private List <float> GetCautionaryRightExtenderX2s(CautionaryChordSymbol cautionaryChordSymbol1,
                                                           List <NoteObject> noteObjects, List <float> x1s, List <float> ys, float hairlinePadding)
        {
            List <float> x2s     = new List <float>();
            NoteObject   no2     = GetFollowingChordRestOrBarlineSymbol(noteObjects);
            Barline      barline = no2 as Barline;
            ChordSymbol  chord2  = no2 as ChordSymbol;
            RestSymbol   rest2   = no2 as RestSymbol;

            if (barline != null)
            {
                float x2 = barline.Metrics.OriginX;
                x2s = GetEqualFloats(x2, x1s.Count);
            }
            else if (chord2 != null)
            {
                x2s = GetX2sFromChord2(ys, chord2.ChordMetrics, hairlinePadding);
            }
            else if (rest2 != null)
            {
                float x2 = rest2.Metrics.Left - hairlinePadding;
                x2s = GetEqualFloats(x2, x1s.Count);
            }
            else // no2 == null
            {
                Debug.Assert(no2 == null);
                // This voice has no further chords or rests,
                // so draw extenders to the right margin.
                // extend to the right margin
                PageFormat pageFormat     = cautionaryChordSymbol1.Voice.Staff.SVGSystem.Score.PageFormat;
                float      rightMarginPos = pageFormat.RightMarginPos;
                float      gap            = pageFormat.Gap;
                x2s = GetEqualFloats(rightMarginPos + gap, ys.Count);
            }
            return(x2s);
        }
Пример #12
0
 public NoteObjectMoment(NoteObject noteObject, int msPosition)
 {
     _msPosition = msPosition;
     AddNoteObject(noteObject);
 }
Пример #13
0
 public abstract Metrics NoteObjectMetrics(Graphics graphics, NoteObject noteObject, VerticalDir voiceStemDirection, double gap, PageFormat pageFormat, string currentClefType);
Пример #14
0
        private void GetStaffParameters(NoteObject rootObject)
        {
            // If a staff has two voices, both should contain the same clefs.
            // The clefs are, however, different objects in the two voices:
            // clef.IsVisible may be true in one voice and false in the other one.

            Voice voice = rootObject.Voice;
            _staffOriginY = voice.Staff.Metrics.StafflinesTop;

            _nStafflines = voice.Staff.NumberOfStafflines;
            foreach(NoteObject noteObject in voice.NoteObjects)
            {
                ClefSymbol cs = noteObject as ClefSymbol;
                if(cs != null)
                    _clef = cs;
                if(noteObject == rootObject)
                    break;
            }
        }
Пример #15
0
 public abstract Metrics NoteObjectMetrics(Graphics graphics, NoteObject noteObject, VerticalDir voiceStemDirection, float gap, float storkeWidth);
Пример #16
0
 public void Add(NoteObject noteObject)
 {
     DurationSymbol durationSymbol = noteObject as DurationSymbol;
     if(durationSymbol != null && _absMsPosition != durationSymbol.AbsMsPosition)
         throw new InvalidOperationException("Attempt to add a non-synchronous DurationSymbol to a MomentSymbol.");
     _noteObjects.Add(noteObject);
 }
Пример #17
0
        private void AddNoteObject(NoteObject noteObject)
        {
            DurationSymbol durationSymbol = noteObject as DurationSymbol;
            if(durationSymbol != null && _noteObjects.Count > 0)
            {
                Debug.Assert(durationSymbol.AbsMsPosition == _absMsPosition);
                Debug.Assert(durationSymbol.Voice.Staff == _noteObjects[0].Voice.Staff);
            }
            if(noteObject is ClefSymbol)
            {

            }
            _noteObjects.Add(noteObject);
        }
Пример #18
0
        public override Metrics NoteObjectMetrics(Graphics graphics, NoteObject noteObject, VerticalDir voiceStemDirection, float gap, float strokeWidth)
        {
            Metrics returnMetrics = null;
            ClefSymbol clef = noteObject as ClefSymbol;
            Barline barline = noteObject as Barline;
            CautionaryOutputChordSymbol cautionaryOutputChordSymbol = noteObject as CautionaryOutputChordSymbol;
            CautionaryInputChordSymbol cautionaryInputChordSymbol = noteObject as CautionaryInputChordSymbol;
            ChordSymbol chord = noteObject as ChordSymbol;
            RestSymbol rest = noteObject as RestSymbol;
            if(barline != null)
            {
                returnMetrics = new BarlineMetrics(graphics, barline, gap);
            }
            else if(clef != null)
            {
                if(clef.ClefType != "n")
                    returnMetrics = new ClefMetrics(clef, gap);
            }
            else if(cautionaryOutputChordSymbol != null)
            {
                returnMetrics = new ChordMetrics(graphics, cautionaryOutputChordSymbol, voiceStemDirection, gap, strokeWidth);
            }
            else if(cautionaryInputChordSymbol != null)
            {
                returnMetrics = new ChordMetrics(graphics, cautionaryInputChordSymbol, voiceStemDirection, gap, strokeWidth);
            }
            else if(chord != null)
            {
                returnMetrics = new ChordMetrics(graphics, chord, voiceStemDirection, gap, strokeWidth);
            }
            else if(rest != null)
            {
                // All rests are originally created on the centre line.
                // They are moved vertically later, if they are on a 2-Voice staff.
                returnMetrics = new RestMetrics(graphics, rest, gap, noteObject.Voice.Staff.NumberOfStafflines, strokeWidth);
            }

            return returnMetrics;
        }
Пример #19
0
        /// <summary>
        /// Writes out an SVG Voice
        /// The following NoteObject types are only written if voiceIndex == 0:
        ///   Barline, Clef, SmallClef, KeySignature, TimeSignature.
        /// </summary>
        /// <param name="w"></param>
        public virtual void WriteSVG(SvgWriter w, int voiceIndex, List <CarryMsgs> carryMsgsPerChannel, bool graphicsOnly)
        {
            bool suppressEndOfScoreBarline = false;

            for (int i = 0; i < NoteObjects.Count; ++i)
            {
                NoteObject noteObject = NoteObjects[i];
                if (noteObject is Barline barline && voiceIndex == 0)
                {
                    bool   isLastNoteObject = (i == (NoteObjects.Count - 1));
                    double top    = Staff.Metrics.StafflinesTop;
                    double bottom = Staff.Metrics.StafflinesBottom;
                    if (barline.IsVisible && !suppressEndOfScoreBarline)
                    {
                        barline.WriteSVG(w, top, bottom, isLastNoteObject, true);
                    }
                    barline.WriteDrawObjectsSVG(w);
                }
                if (noteObject is CautionaryChordSymbol cautionaryChordSymbol)
                {
                    cautionaryChordSymbol.WriteSVG(w);
                }
                if (noteObject is OutputChordSymbol outputChordSymbol)
                {
                    M.Assert(carryMsgsPerChannel != null);
                    outputChordSymbol.WriteSVG(w, this.MidiChannel, carryMsgsPerChannel[this.MidiChannel], graphicsOnly);
                }
                if (noteObject is OutputRestSymbol outputRestSymbol)
                {
                    M.Assert(carryMsgsPerChannel != null);
                    outputRestSymbol.WriteSVG(w, this.MidiChannel, carryMsgsPerChannel[this.MidiChannel], graphicsOnly);
                }
                if (noteObject is Clef clef && voiceIndex == 0)
                {
                    if (clef.Metrics != null)
                    {
                        // if this is the first barline, the staff name and (maybe) barnumber will be written.
                        ClefMetrics cm = clef.Metrics as ClefMetrics;
                        clef.WriteSVG(w, cm.ClefID, cm.OriginX, cm.OriginY);
                    }
                }
                if (noteObject is SmallClef smallClef && voiceIndex == 0)
                {
                    if (smallClef.Metrics != null)
                    {
                        SmallClefMetrics scm = smallClef.Metrics as SmallClefMetrics;
                        smallClef.WriteSVG(w, scm.ClefID, scm.OriginX, scm.OriginY);
                    }
                }
                if (noteObject is KeySignature keySignature && voiceIndex == 0)
                {
                    keySignature.WriteSVG(w, keySignature.Fifths.ToString(), keySignature.Metrics.OriginX, keySignature.Metrics.OriginY);
                }
                if (noteObject is TimeSignature timeSignature && voiceIndex == 0)
                {
                    timeSignature.WriteSVG(w, timeSignature.Signature, timeSignature.Metrics.OriginX, timeSignature.Metrics.OriginY);
                }
                if (noteObject is RepeatSymbol repeatSymbol && voiceIndex == 0)
                {
                    bool   isLastNoteObject = (i == (NoteObjects.Count - 1));
                    double top    = Staff.Metrics.StafflinesTop;
                    double bottom = Staff.Metrics.StafflinesBottom;
                    repeatSymbol.WriteSVG(w, top, bottom, isLastNoteObject, true);

                    suppressEndOfScoreBarline = (i == (NoteObjects.Count - 2));
                }
            }
        }
Пример #20
0
        /// <summary>
        /// There is still one system per bar.
        /// </summary>
        /// <param name="systems"></param>
        public void ConvertVoiceDefsToNoteObjects(List <SvgSystem> systems)
        {
            byte[] currentChannelVelocities = new byte[systems[0].Staves.Count];

            List <ClefChangeDef> voice0ClefChangeDefs = new List <ClefChangeDef>();
            List <ClefChangeDef> voice1ClefChangeDefs = new List <ClefChangeDef>();

            for (int systemIndex = 0; systemIndex < systems.Count; ++systemIndex)
            {
                SvgSystem system            = systems[systemIndex];
                int       visibleStaffIndex = -1;
                for (int staffIndex = 0; staffIndex < system.Staves.Count; ++staffIndex)
                {
                    Staff staff = system.Staves[staffIndex];
                    if (!(staff is InvisibleOutputStaff))
                    {
                        visibleStaffIndex++;
                    }
                    voice0ClefChangeDefs.Clear();
                    voice1ClefChangeDefs.Clear();
                    for (int voiceIndex = 0; voiceIndex < staff.Voices.Count; ++voiceIndex)
                    {
                        Voice voice           = staff.Voices[voiceIndex];
                        float musicFontHeight = (voice is OutputVoice) ? _pageFormat.MusicFontHeight : _pageFormat.MusicFontHeight * _pageFormat.InputStavesSizeFactor;
                        if (!(staff is InvisibleOutputStaff))
                        {
                            Debug.Assert(_pageFormat.ClefsList[visibleStaffIndex] != null);
                            voice.NoteObjects.Add(new ClefSymbol(voice, _pageFormat.ClefsList[visibleStaffIndex], musicFontHeight));
                        }
                        bool firstLmdd = true;

                        if (staff is InputStaff)
                        {
                            InputVoice inputVoice = staff.Voices[voiceIndex] as InputVoice;
                            if (systemIndex == 0)
                            {
                                InputVoiceDef inputVoiceDef = inputVoice.VoiceDef as InputVoiceDef;
                                inputVoice.SetMidiChannel(inputVoiceDef.MidiChannel, systemIndex);
                            }
                        }
                        foreach (IUniqueDef iud in voice.VoiceDef.UniqueDefs)
                        {
                            NoteObject noteObject =
                                SymbolSet.GetNoteObject(voice, iud, firstLmdd, ref currentChannelVelocities[staffIndex], musicFontHeight);

                            ClefChangeSymbol clefChangeSymbol = noteObject as ClefChangeSymbol;
                            if (clefChangeSymbol != null)
                            {
                                if (voiceIndex == 0)
                                {
                                    voice0ClefChangeDefs.Add(iud as ClefChangeDef);
                                }
                                else
                                {
                                    voice1ClefChangeDefs.Add(iud as ClefChangeDef);
                                }
                            }

                            voice.NoteObjects.Add(noteObject);

                            firstLmdd = false;
                        }
                    }

                    if (voice0ClefChangeDefs.Count > 0 || voice1ClefChangeDefs.Count > 0)
                    {
                        // the main clef on this staff in the next system
                        SetNextSystemClefType(staffIndex, voice0ClefChangeDefs, voice1ClefChangeDefs);
                    }

                    if (staff.Voices.Count == 2)
                    {
                        InsertInvisibleClefChangeSymbols(staff.Voices, voice0ClefChangeDefs, voice1ClefChangeDefs);

                        CheckClefTypes(staff.Voices);

                        StandardSymbolSet standardSymbolSet = SymbolSet as StandardSymbolSet;
                        if (standardSymbolSet != null)
                        {
                            standardSymbolSet.ForceNaturalsInSynchronousChords(staff);
                        }
                    }
                }
            }
        }
Пример #21
0
 public abstract Metrics NoteObjectMetrics(Graphics graphics, NoteObject noteObject, VerticalDir voiceStemDirection, float gap, float storkeWidth);
Пример #22
0
 public NoteObjectMoment(NoteObject noteObject, int msPosition)
 {
     _msPosition = msPosition;
     AddNoteObject(noteObject);
 }