CueVoice - LilyPond program-reference
Description: LilyPond program-reference

Next: Devnull, Previous: ChordNames, Up: Contexts

#### CueVoice

Corresponds to a voice on a staff. This context handles the conversion of dynamic signs, stems, beams, super- and subscripts, slurs, ties, and rests.

You have to instantiate this explicitly if you want to have multiple voices on the same staff.

This context also accepts commands for the following context(s):

Voice

This context creates the following layout objects:

Arpeggio, Beam, BreathingSign, ClusterSpannerBeacon, ClusterSpanner, CombineTextScript, Dots, DoublePercentRepeatCounter, DoublePercentRepeat, DynamicLineSpanner, DynamicText, Fingering, Glissando, Hairpin, LaissezVibrerTieColumn, LaissezVibrerTie, MultiMeasureRestNumber, MultiMeasureRestText, MultiMeasureRest, NoteColumn, NoteHead, NoteSpacing, PercentRepeatCounter, PercentRepeat, PhrasingSlur, RepeatSlash, RepeatTieColumn, RepeatTie, Rest, ScriptColumn, Script, Slur, StemTremolo, Stem, TextScript, TextSpanner, TieColumn, Tie, TrillPitchAccidental, TrillPitchGroup, TrillPitchHead, TrillSpanner, TupletBracket, TupletNumber and VoiceFollower.

This context sets the following properties:

- Set grob-property `length-fraction` in Beam to `0.629960524947437`.
- Set grob-property `length-fraction` in Stem to `0.629960524947437`.
- Set translator property `fontSize` to `-4`
- Set translator property `localKeySignature` to `'()`

This context is a `bottom' context; it can not contain other contexts.

This context is built from the following engravers:

`Skip_event_swallow_translator`
  Swallow \skip.

  Music types accepted:

  skip-event

`Grace_engraver`
  Set font size and other properties for grace notes.

  Properties (read)

  `graceSettings` (list)
    Overrides for grace notes. This property should be manipulated through the `add-grace-property` function.
`Tuplet_engraver`
  Catch Time_scaled_music and generate appropriate bracket

  Music types accepted:

  time-scaled-music

  Properties (read)

  `tupletNumberFormatFunction` (procedure)
    Function taking a music as input, producing a string. This function is called to determine the text to print on a tuplet bracket.
  `tupletSpannerDuration` (moment)
    Normally a tuplet bracket is as wide as the `\times` expression that gave rise to it. By setting this property, you can make brackets last shorter. Example

                       {
                       \set tupletSpannerDuration = #(ly:make-moment 1 4)
                       \times 2/3 { c8 c c c c c }
                       }

    .

  `tupletFullLength` (boolean)
    If set, the tuplet is printed upto the start of the next note.
  This engraver creates the following layout objects: TupletBracket and TupletNumber.
`Tie_engraver`
  Generate ties between noteheads of equal pitch.

  Music types accepted:

  tie-event

  Properties (read)

  `tieWaitForNote` (boolean)
    If true, tied notes do not have to follow each other directly. This can be used for writing out arpeggios
  Properties (write)
  `tieMelismaBusy` (boolean)
    Signal whether a tie is present.
  This engraver creates the following layout objects: Tie and TieColumn.
`Slur_engraver`
  Build slur grobs from slur events

  Music types accepted:

  slur-event

  Properties (read)

  `slurMelismaBusy` (boolean)
    Signal if a slur is present.
  `doubleSlurs` (boolean)
    When set, two slurs are created for every slurred note, one above and one below the chord.
  This engraver creates the following layout objects: Slur.
`Cluster_spanner_engraver`
  Engraves a cluster using Spanner notation

  Music types accepted:

  cluster-note-event and busy-playing-event

  This engraver creates the following layout objects: ClusterSpanner and ClusterSpannerBeacon.

`Phrasing_slur_engraver`
  Print phrasing slurs. Similar to Slur_engraver

  Music types accepted:

  phrasing-slur-event

  This engraver creates the following layout objects: PhrasingSlur.

`Rhythmic_column_engraver`
  Generates NoteColumn, an objects that groups stems, noteheads and rests.

  This engraver creates the following layout objects: NoteColumn and NoteSpacing.

`Script_column_engraver`

  This engraver creates the following layout objects: ScriptColumn.

`Script_engraver`
  Handles note scripted articulations.

  Music types accepted:

  script-event and articulation-event

  Properties (read)

  `scriptDefinitions` (list)
    Description of scripts. This is used by Script_engraver for typesetting note-super/subscripts. See `scm/script.scm` for more information
  This engraver creates the following layout objects: Script.
`Fingering_engraver`
  Create fingering-scripts

  Music types accepted:

  fingering-event

  This engraver creates the following layout objects: Fingering.

`Dynamic_engraver`
  This engraver creates hairpins, dynamic texts, and their vertical alignments. The symbols are collected onto a DynamicLineSpanner grob which takes care of vertical positioning.

  Music types accepted:

  absolute-dynamic-event, crescendo-event and decrescendo-event

  This engraver creates the following layout objects: DynamicLineSpanner, DynamicText, Hairpin and TextSpanner.

`Text_engraver`
  Create text-scripts

  Music types accepted:

  text-script-event

  This engraver creates the following layout objects: TextScript.

`Part_combine_engraver`
  Part combine engraver for orchestral scores: Print markings a2, Solo, Solo II, and unisono

  Music types accepted:

  part-combine-event

  Properties (read)

  `printPartCombineTexts` (boolean)
    set Solo/A due texts in the part combiner?
  `soloText` (string)
    text for begin of solo when part-combining.
  `soloIIText` (string)
    text for begin of solo for voice “two” when part-combining.
  `aDueText` (string)
    Text to print at a unisono passage.
  This engraver creates the following layout objects: CombineTextScript.
`Melisma_translator`
  This translator collects melisma information about ties, beams, and user settings (`melismaBusy`, and signals it to the `ddlyrics` code.

  Music types accepted:

  melisma-playing-event and melisma-span-event

  Properties (read)

  `melismaBusy` (boolean)
    Signifies whether a melisma is active. This can be used to signal melismas on top of those automatically detected.
  `melismaBusyProperties` (list)
    List of properties (symbols) to determine whether a melisma is playing. Setting this property will influence how lyrics are aligned to notes. For example, if set to `#'(melismaBusy beamMelismaBusy)`, only manual melismata and manual beams are considered. Possible values include `melismaBusy`, `slurMelismaBusy`, `tieMelismaBusy`, and `beamMelismaBusy`
  `slurMelismaBusy` (boolean)
    Signal if a slur is present.
  `tieMelismaBusy` (boolean)
    Signal whether a tie is present.
  `beamMelismaBusy` (boolean)
    Signal if a beam is present.
`Slash_repeat_engraver`
  Make beat repeats.

  Music types accepted:

  repeated-music

  Properties (read)

  `measureLength` (moment)
    Length of one measure in the current time signature.
  This engraver creates the following layout objects: RepeatSlash.
`Percent_repeat_engraver`
  Make whole bar and double bar repeats.

  Music types accepted:

  repeated-music

  Properties (read)

  `measureLength` (moment)
    Length of one measure in the current time signature.
  `currentCommandColumn` (layout object)
    Grob that is X-parent to all current breakable (clef, key signature, etc.) items.
  `countPercentRepeats` (boolean)
    If set, produce counters for percent repeats.
  This engraver creates the following layout objects: DoublePercentRepeat, DoublePercentRepeatCounter, PercentRepeat and PercentRepeatCounter.
`Chord_tremolo_engraver`
  Generates beams for tremolo repeats.

  Music types accepted:

  repeated-music

  This engraver creates the following layout objects: Beam.

`New_fingering_engraver`
  Create fingering-scripts for notes in a new chord. This engraver is ill-named, since it also takes care of articulations and harmonic note heads

  Properties (read)

  `fingeringOrientations` (list)
    List of symbols, containing ``left`', ``right`', ``up`' and/or ``down`'. This list determines where fingerings are put relative to the chord being fingered.
  This engraver creates the following layout objects: Fingering.
`Auto_beam_engraver`
  Generate beams based on measure characteristics and observed Stems. Uses beatLength, measureLength and measurePosition to decide when to start and stop a beam. Overriding beaming is done through Stem_engraver properties `stemLeftBeamCount` and `stemRightBeamCount`.

  Music types accepted:

  beam-forbid-event

  Properties (read)

  `autoBeaming` (boolean)
    If set to true then beams are generated automatically.
  `autoBeamSettings` (list)
    Specifies when automatically generated beams should begin and end. See Setting automatic beam behavior for more information.
  `beatLength` (moment)
    The length of one beat in this time signature.
  `subdivideBeams` (boolean)
    If set, multiple beams will be subdivided at beat positions by only drawing one beam over the beat.
  This engraver creates the following layout objects: Beam.
`Grace_beam_engraver`
  Handles Beam events by engraving Beams. If omitted, then notes will be printed with flags instead of beams. Only engraves beams when we are at grace points in time.

  Music types accepted:

  beam-event

  Properties (read)

  `beamMelismaBusy` (boolean)
    Signal if a beam is present.
  `beatLength` (moment)
    The length of one beat in this time signature.
  `allowBeamBreak` (boolean)
    If true allow line breaks for beams over bar lines.
  `subdivideBeams` (boolean)
    If set, multiple beams will be subdivided at beat positions by only drawing one beam over the beat.
  This engraver creates the following layout objects: Beam.
`Beam_engraver`
  Handles Beam events by engraving Beams. If omitted, then notes will be printed with flags instead of beams.

  Music types accepted:

  beam-event

  Properties (read)

  `beamMelismaBusy` (boolean)
    Signal if a beam is present.
  `beatLength` (moment)
    The length of one beat in this time signature.
  `subdivideBeams` (boolean)
    If set, multiple beams will be subdivided at beat positions by only drawing one beam over the beat.
  This engraver creates the following layout objects: Beam.
`Stem_engraver`
  Create stems and single-stem tremolos. It also works together with the beam engraver for overriding beaming.

  Music types accepted:

  tremolo-event

  Properties (read)

  `tremoloFlags` (integer)
    Number of tremolo flags to add if no number is specified.
  `stemLeftBeamCount` (integer)
    Specify the number of beams to draw on the left side of the next note. Overrides automatic beaming. The value is only used once, and then it is erased.
  `stemRightBeamCount` (integer)
    See `stemLeftBeamCount`.
  This engraver creates the following layout objects: Stem and StemTremolo.
`Rest_engraver`

  Music types accepted:

  rest-event

  Properties (read)

  `middleCPosition` (number)
    Place of the middle C, measured in half staff-spaces. Usually determined by looking at `clefPosition` and `clefGlyph`.
  This engraver creates the following layout objects: Dots and Rest.
`Note_heads_engraver`
  Generate noteheads.

  Music types accepted:

  note-event and busy-playing-event

  Properties (read)

  `middleCPosition` (number)
    Place of the middle C, measured in half staff-spaces. Usually determined by looking at `clefPosition` and `clefGlyph`.
  This engraver creates the following layout objects: Dots and NoteHead.
`Breathing_sign_engraver`

  Music types accepted:

  breathing-event

  This engraver creates the following layout objects: BreathingSign.

`Ligature_bracket_engraver`
  Handles Ligature_events by engraving Ligature brackets.

  Music types accepted:

  ligature-event

  This engraver creates the following layout objects: TupletBracket.

`Glissando_engraver`
  Engrave a glissandi

  Music types accepted:

  glissando-event

  Properties (read)

  `followVoice` (boolean)
    If set, note heads are tracked across staff switches by a thin line
  This engraver creates the following layout objects: Glissando.
`Note_head_line_engraver`
  Engrave a line between two note heads, for example a glissando. If followVoice is set, staff switches also generate a line.

  Music types accepted:

  glissando-event

  Properties (read)

  `followVoice` (boolean)
    If set, note heads are tracked across staff switches by a thin line
  This engraver creates the following layout objects: Glissando and VoiceFollower.
`Repeat_tie_engraver`
  Create Laissez vibrer items.

  Music types accepted:

  repeat-tie-event

  This engraver creates the following layout objects: RepeatTie and RepeatTieColumn.

`Laissez_vibrer_engraver`
  Create Laissez vibrer items.

  Music types accepted:

  laissez-vibrer-event

  This engraver creates the following layout objects: LaissezVibrerTie and LaissezVibrerTieColumn.

`Forbid_line_break_engraver`
  Forbid line breaks when note heads are still playing at some point.

  Properties (read)

  `busyGrobs` (list)
    a queue of (end-moment . GROB) conses. This is for internal (C++) use only. This property contains the grobs which are still busy (e.g. note heads, spanners, etc.)
`Grob_pq_engraver`
  Administrate when certain grobs (eg. note heads) stop playing

  Properties (read)

  `busyGrobs` (list)
    a queue of (end-moment . GROB) conses. This is for internal (C++) use only. This property contains the grobs which are still busy (e.g. note heads, spanners, etc.)
  Properties (write)
  `busyGrobs` (list)
    a queue of (end-moment . GROB) conses. This is for internal (C++) use only. This property contains the grobs which are still busy (e.g. note heads, spanners, etc.)
`Trill_spanner_engraver`
  Create trill spanner from a Music.

  Music types accepted:

  trill-span-event

  This engraver creates the following layout objects: TrillSpanner.

`Text_spanner_engraver`
  Create text spanner from a Music.

  Music types accepted:

  text-span-event

  This engraver creates the following layout objects: TextSpanner.

`Multi_measure_rest_engraver`
  Engraves multi-measure rests that are produced with `R`. Reads measurePosition and currentBarNumber to determine what number to print over the MultiMeasureRest. Reads measureLength to determine if it should use a whole rest or a breve rest to represent 1 measure

  Music types accepted:

  multi-measure-rest-event and multi-measure-text-event

  Properties (read)

  `currentBarNumber` (integer)
    Contains the current barnumber. This property is incremented at every bar line.
  `restNumberThreshold` (number)
    If a multimeasure rest has more measures than this, a number is printed.
  `breakableSeparationItem` (layout object)
    The breakable items in this time step, for this staff.
  `currentCommandColumn` (layout object)
    Grob that is X-parent to all current breakable (clef, key signature, etc.) items.
  `measurePosition` (moment)
    How much of the current measure have we had. This can be set manually to create incomplete measures.
  `measureLength` (moment)
    Length of one measure in the current time signature.
  This engraver creates the following layout objects: MultiMeasureRest, MultiMeasureRestNumber and MultiMeasureRestText.
`Arpeggio_engraver`
  Generate an Arpeggio symbol

  Music types accepted:

  arpeggio-event

  This engraver creates the following layout objects: Arpeggio.

`Output_property_engraver`
  Apply a procedure to any grob acknowledged.

  Music types accepted:

  layout-instruction

`Pitched_trill_engraver`
  Print the bracketed notehead after a notehead with trill.

  This engraver creates the following layout objects: TrillPitchAccidental, TrillPitchGroup and TrillPitchHead.

`Font_size_engraver`
  Puts fontSize into font-size grob property.

  Properties (read)

  `fontSize` (number)
    The relative size of all grobs in a context.

This page is for LilyPond-2.8.8 (stable-branch).

Other languages: English.
Using automatic language selection.