\begin{document}
\maketitle
+[THIS IS WORK IN PROGRESS. THIS PAPER IS NOT FINISHED]
+
% -*-LaTeX-*-
\section{Introduction}
redef(code)(1)(tt(ARG1))
+
COMMENT(
TODO:
the use of semicolons needs to be documented once it settles down
- \times needs documentation with examples somewhere once it works (?)
paper size?
the explanation of how lyrics mode parses words seems ridiculous.
Is there a simple way to explain this, or is the behavior
accordion symbols
extender* (see extender.ly)
\repeat & \alternative -> probably should have an example
+ properties:
+ unfoldRepeats
+ voltaVisibility
+ property: stemLeftBeamCount stemRightBeamCount
+ interstaff beams (beam-interstaff.ly)
+ interstaff slurs (see preludes-1.ly)
+ boolean property barAuto
+ property: noteheadStyle
+ harmonics: test/harmonics.fly
+ autobeamer
+ properties: beamAutoEndx ??? rational string "1/2"
+ beamAutoBegin
+ beamAutoEnd
+ beamAuto
+ ScriptPadding
+ Direction
+ chordNameStyle (banter)
+ chordInversionPreserve
+ createInitdefaultClef
+ dynamicStyle
+ singleStaffBracket
+ numberOfStaffLines
+
+
+ {Mark,BarNumber,Margin}{Direction,ScriptPadding}
+
+
)
-COMMENT( This document contains Mudela fragments. You need at least
+COMMENT(
+This document contains Mudela fragments. You need at least
Yodl-1.30.18 to convert this to tex or html.
-
-TODO
-
-in stead <-> instead
)
htmlbodyopt(bgcolor)(white)
whentexinfo(notableofcontents())
-article(Mudela 1.0.7 / LilyPond 1.1.8 Reference Manual)
+article(Mudela 1.0.14 / LilyPond 1.1.27 Reference Manual)
(Adrian Mariano, Han-Wen Nienhuys and Jan Nieuwenhuizen)
(nop()PIPETHROUGH(date "+%B %d, %Y")()()nop())
letter and are entirely alphanumeric. It is also impossible to refer
to an identifier whose name is the same as the name of a keyword. The
following words are keywords:
-verb(absdynamic grouping mm relative
-accepts header musicalpitch remove
-alternative in name repeat tempo
-bar include notenames scm time
-cadenza key notes scmfile times
-clef keysignature paper score translator
-cm lyrics partial script transpose
-consists maininput penalty shape type
-duration mark property skip version
-font midi pt spandynamic)
+verb(absdynamic duration mark property skip
+accepts font midi pt spandynamic
+alternative grouping mm relative tempo
+bar header musicalpitch remove time
+cadenza in name repeat times
+chordmodifier include notenames scm translator
+chords key notes scmfile transpose
+clef keysignature paper score type
+cm lyrics partial script version
+consists maininput penalty shape)
The right hand side of an identifier assignment is parsed completely
when the assignment is made. It therefore must have any context
treated as a string. If you mistype a notename, the parser will most
likely complain that you should be in code(\lyrics) mode to do lyrics.
+dit(Chord mode) Chord mode is instroduced by the keyword code(\chords).
+Very similar to Note mode.
+COMMENT(I'm not sure how it differs)
+
dit(Lyric mode) Lyrics mode is introduced by the keyword
code(\lyrics). This mode is has rules that make it easy to include
punctuation and diacritical marks in words. A word in Lyrics mode
a'4. b'4.
)
-In addition, the duration can be followed by a multiplier which is
-introduced with the asterisk code(*) and can be an integer or a
-fraction. The multiplier changes the duration that LilyPond uses
-internally for the note, but for notes it
-does not change the symbol that is printed.
+Extra long notes can be obtained using the code(\breve) and
+code(longa) durations:
mudela(fragment,verbatim,center)(
-c'4*2 c'4*2 d'8*2/3 d'8*2/3
+c'\breve gis'\longa
+)
+
+In order to get triplets and other tuplets, you must use the
+code(\times) keyword which multiplies the duration by a fraction. The
+syntax is code(\times) var(fraction) var(music). The length of all of
+the specified music will be multiplied by the fraction and the
+fraction's denominator will be printed over the notes. The most
+common tuplet is the triplet in which 3 notes have the length of 2, so
+the notes are 2/3 their written length:
+mudela(fragment,verbatim,center)( b'4 \times 2/3 {c'4 c' c'} d'4 d'4 )
+If you try to use code(\times) as the first thing in your music, you
+may encounter the warning ``No one to print a tuplet start bracket''.
+This happens because the Tuplet-engraver is in Voice and no Voice has
+been created yet. You must explicitly specify the Voice context in
+this situation
+mudela(fragment,verbatim,center)(
+\type Voice { \times 2/3 {c'4 d' e'}}
)
+
+A shorthand for code(\times) is to write code(*)var(fraction) after a
+duration. This shorthand will not label triplets correctly, but
+it is convenient for long rests.
For long rests with durations equal to an integer number of whole notes,
LilyPond produces output that indicates the duration of the rest. If you use
code(r) then one rest symbol will be printed and several measures left blank.
If you use code(R) then all of the measure will be filled with whole rests.
+mudela(fragment,verbatim,center)(
+r1 r1*3 R1*3
+)
If you set the code(Score.SkipBars) property, then only one measure will be
printed; with code(R), a number indicating the length of the rest will be
displayed.
mudela(fragment,verbatim,center)(
-r1*3 R1*3
\property Score.SkipBars=1
-r1*3 R1*3)
-
-Extra long notes can be obtained using the code(\breve) and
-code(longa) durations:
+r1 r1*3 R1*3
+)
+Even though the code(\times) command is not explicit, it is still
+necessary to specify a code(Voice) context if the music begins with
+rests lengthened using code(*).
+Otherwise, the following will result:
mudela(fragment,verbatim,center)(
-c'\breve gis'\longa
+R1*3 c'1 d'
)
-
-subsect(Note Spanners: Beams, Tuplets, Slurs and Ties)
+subsect(Note Spanners: Beams, Slurs and Ties)
A beam is specified by surrounding the beamed notes with brackets
code([) and code(]).
mudela(fragment,verbatim,center)(
-[a'8 a'] [a'16 a' a' a']
+[a'8 a'] [a'16 a' a' a']
+)
+Some more elaborate constructions:
+mudela(fragment,verbatim,center)(
+[a'16 <a' c''> c'' <a' c''>]
+\times 2/3 { [e'8 f' g'] }
)
-
-[EXPLAIN TUPLETS HERE]
Another type of spanner is the slur. Slurs connects chords and try to
avoid crossing stems. A slur is started with code(CHAR(40)) and stopped with
e' ~ e' <c' e' g'> ~ <c' e' g'>
)
+It is possible to create beams and slurs that cross staffs by switching the
+context:
+mudela(fragment,verbatim,center)(
+<
+\type Staff=one \notes\relative c'{
+ \stemup
+ [c8 c \translator Staff=two \stemup c c]
+ \translator Staff=one
+ d4( \translator Staff=two )a4
+ }
+\type Staff=two \notes{ \clef bass;}
+>
+)
+
+
+COMMENT(!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
subsect(Note Ornaments)
c''-\open c''-\flageolet c''-\reverseturn
c''-\trill
c''-\prall c''-\mordent c''-\prallprall c''-\prallmordent
- c''-\upprall c''-\downprall c''-\thumb}
+ c''-\upprall c''-\downprall c''-\thumb }
\type Lyrics \lyrics{
accent marcato staccatissimo fermata stopped
staccato tenuto upbow downbow lheel rheel ltoe rtoe turn
open flageolet reverseturn
trill prall
- mordent prallprall prallmordent uprall downprall thumb}>
- \paper{linewidth = 5.875\in;
- indent = 0.0;
- }
-}
+ mordent prallprall prallmordent uprall downprall thumb }
+ >
+ \paper{ linewidth = 5.875\in;
+ indent = 0.0; }
+ }
)
COMMENT( The following are defined in script.ly but do not work:
c'' \< \! c'' d'' \decr e'' \rced
< f''1 {s4 \< \! s4 \> \! s2 } >)
+
+COMMENT(Broken!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
+
Tremolo marks can be printed by a note by adding code(:)[var(length)]
after the note. The length must be at least 8. A var(length) value
of 8 gives one line across the note stem.
code(\transpose) have no effect on notes that appear inside the
code(\transpose).
+sect(Chords)
+
+Chords can be entered either by name or by listing the notes in angle brackets.
+Chords can be displayed either as notes or by name. To enter chords by name,
+either place them inside the code(\chords) keyword, or use
+code(\notes) and surround them with
+code(@) characters.
+Chord names have the form
+var(tonic)[var(duration)][code(-)var(modifier)][code(^)var(subtractions)][code(/)var(inversion)]
+The var(tonic) should be the tonic note of the chord, and the var(duration) is
+the chord duration in the usual notation. There are two kinds of modifiers.
+One type is chord additions, which are obtained by listing intervals separated
+by dots. An interval is written by its number with an optional code(+) or
+code(-) to indicate raising or lowering by half a step. A chord additions has
+two effects: it adds the specified interval and all lower odd numbered
+intervals to the chord, and it may lower or raise the specified interval.
+Intervals can be separated by a dot (code(.)) if you need to list
+several unmodified intervals.
+Repeating a code(-) character will remove a half step from the preceeding
+interval.
+mudela(fragment,verbatim,center)(
+\transpose c''{
+\chords{
+ c1 c-3- c-7 c-8 c-9
+ c-9-5+7+ c-3-5- c-4.6.8
+}})
+The second type of modifier that may appear after the code(-) is
+a named modifier.
+Named modifiers are listed in the file file(chord-modifiers.ly). The
+available modifiers are code(m) and code(min) which lower
+the 3rd half a step, code(aug) which raises the 5th, code(dim) which lowers
+the 5th, code(maj) which adds a raised 7th, and code(sus) which replaces the
+5th with a 4th.
+mudela(fragment,verbatim,center)(
+\transpose c''{
+\chords{
+ c1-m c-min c-maj c-aug c-dim c-sus
+}})
+
+Chord subtractions are used to eliminate notes from a chord. The notes to be
+subtracted are listed after a code(^) character, separated by dots.
+mudela(fragment,verbatim,center)(
+\transpose c''{
+\chords{
+ c1^3 c-7^5.3 c-8^7
+}})
+
+Chord inversions can be specified by appending code(/) and the name of a
+single note to a chord. This has the effect of lowering the specified note by
+an octave so it becomes the lowest note in the chord. If the
+specified note is not in the chord then a warning will be printed.
+mudela(fragment,verbatim,center)(
+\transpose c'''{
+ @c1@ @c/e@ @c/g@ @c-7/e@
+})
+Throughout these examples, chords have been shifted around the staff
+using code(\transpose). The code(\relative) keyword has odd effects
+when combined with named chords.
+
+For displaying printed chord names, use the code(ChordNames) context.
+The chords may be entered either using the notation described above,
+or directly using angle brackets.
+mudela(fragment,verbatim)(
+<
+ \type ChordNames { \chords{ a b c} \notes{ < d f g > < e g b > } }
+ \type Staff \notes{ a b c' d' e' }
+>
+)
+Lilypond examines chords specified as lists of notes to determine a
+name to give the chord. By default, LilyPond will not try to identify
+chord inversions:
+mudela(fragment,verbatim,center)(
+<
+ \type ChordNames {
+ \notes{ < e' g' c'' > } }
+ \type Staff \notes{ c' }
+>)
+If you want inversions to be recognized, you must set the property
+code(Score.chordInversion):
+mudela(fragment,verbatim,center)(
+<
+ \property Score.chordInversion = 1
+ \type ChordNames {
+ \notes{ < e' g' c'' > } }
+ \type Staff \notes{ c' }
+>)
+
+COMMENT(
+ Two other properties
+ chordInversionPreserve
+ and chordNameStyle = Banter
+ exist. What do these do?
+)
+
+
sect(Lyrics)
Lyrics are entered like notes, with pitches replaced
Why does this warrant an URG?
)
+When one word is attached to many notes, you may
+want a continuous line after the lyric to show this. To achieve
+this effect, add a code(__) lyric after the lyric to be extended.
+This will create
+an extender, a line that extends over the entire duration of
+the lyric. There must be a lyric after the code(__), so if you want
+to extend the final lyric, you will have to end with a blank lyric.
+mudela(verbatim,center)(
+\score{
+< \notes \relative c''{
+ a4()b()c()d c()d()b()a }
+ \type Lyrics \lyrics {
+ foo1 __ bar2. __ _ }
+> })
+
-COMMENT(
-
-sect(Chords and Voices)
-
-Here's a simple chord
-mudela(fragment,verbatim,center)(
-<c e g>
-)
-
-here are a few
-mudela(fragment,verbatim,center)(
-<
- { c'()d'()c' }
- { e'()f'()e' }
- { g'()a'()g' }
->
-)
-
-and similarly voices
-mudela(fragment,verbatim)(
-<
- { \voiceone c'4 g' c' g' }
- { \voicetwo c2 g2 }
->
-)
+COMMENT(Broken!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
-)
sect(Time)
LilyPond aligns all musical objects according to the amount of time
-they occupy. All of these objects have a duration. When music is
+they occupy. All musical objects have a duration. When music is
written sequentially using braces the duration is the sum of the
durations of the elements. When music is stacked into simultaneous music
using angle
)
+sect(Repeats)
+
+In order to specify repeats, use the code(\repeat) keyword. By
+default, repeats are printed with repeat symbols.
+mudela(fragment,verbatim,center)(
+c'1
+\repeat 2 { c'4 d' e' f' }
+\repeat 2 { f' e' d' c' })
+In order to specify alternate endings, use the code(\alternative)
+keyword.
+mudela(fragment,verbatim,center)(
+c'1
+\repeat 2 {c'4 d' e' f'}
+\alternative { {d'2 d'} {f' f} })
+When the repeats involve partial measures, it will be necessary to use
+code(\partial) keywords to indicate which measures are short.
+mudela(fragment,verbatim)(
+\type Staff { \relative c'{
+ \repeat 2 { \partial 4; e | c2 d2 | e2 f2 | }
+ \alternative { { g4 g g } {\partial 2.; a a a a | b1 } }
+}})
+Repeats can be unfolded by setting the unfoldRepeats
+
+
sect(Keywords)
Keywords sometimes appear alone, but usually they require arguments.
mudela(center)(
\score{
\notes{\cadenza 1; \clef alto; c'4_"\kern -10mm alto"
- \clef scarlatti; c'4_"\kern -4mm scarlatti"
+ % \clef scarlatti; c'4_"\kern -4mm scarlatti"
\clef mezzosoprano; c'4^"\kern -10mm mezzosoprano"
\clef soprano; c'4_"\kern -10mm soprano"
\clef treble; c'4^"\kern -6mm treble"
dit(code(\maininput)) Internal command. This command is used for creating init
files like file(init.fly) that read the user file into the middle of another
-file. Using it in a user file will lead to an infinite loop.
+file. It is illegal to use this command in a user file.
dit(code(\mark) var(unsigned)code(;) or code(\mark) var(string)code(;))
Allowed in music only. Prints a mark over or under (depending on the
dit(code(\notes) var(music)) Enter note mode and process the
specified music.
-dit(code(\)code(output) var(string)code(;)) Generate a parse error.
-
dit(code(\paper) var(statmentlist))
Appears in a score block to indicate that the music should be printed
or to set output parameters. Can also appear at the top level to set
This context handles the conversion of noteheads,
dynamic signs, stems, beams, super- and subscripts, slurs, ties and rests.
+dit(code(ChordNamesVoice)) A voice with chord names. Handles printing
+of a line of chord names.
+
+dit(code(ChordNames)) Typesets chord names. Can contain
+code(ChordNamesVoice) contexts.
+
dit(code(Lyrics)) Typesets lyrics. It can contain code(LyricVoice) contexts.
dit(code(Staff)) Handles clefs, bar lines, keys,
together. The bar lines of the contained staffs are connected vertically.
It can contain code(Staff) contexts.
+dit(code(PianoStaff)) Just like code(GrandStaff) but with
+code(minVerticalAlign) set equal to code(maxVerticalAlign) so that
+interstaff beaming and slurring can be used.
+
dit(code(StaffGroup)) Contains code(Staff) or code(RhythmicStaff)
contexsts. Adds a bracket on the left side, grouping the staffs
together. The bar lines of the contained staffs are connected vertically.
force slurs down. The shorthands code(\slurup), code(\slurdown), and
code(\slurboth) are available.
-dit(code(tieYDirection)) Set to code(\free) for free choice of tie
+dit(code(tieydirection)) Set to code(\free) for free choice of tie
direction, set to code(\up) to force ties up, set to code(\down) to
force ties down.
typesetting many voices on one staff. The identifier code(\shift) is
defined to enable this.
-dit(code(dynamicdir)) Determines location of dynamic marks. Set to
+dit(code(dynamicDir)) Determines location of dynamic marks. Set to
code(\up) to print marks above the staff; set to code(\down) to print
marks below the staff.
}
)
+COMMENT(Broken!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
+
)
code(\beamslopedamped), and code(\beamslopezero) each set the
corresponding value.
+dit(code(chordInversion)) Determines whether LilyPond should look for
+chord inversions when translating from notes to chord names. Set to 1
+to find inversions. The default is 0 which does not look for inversions.
+
)
-
+
COMMENT(
bar-number-engraver.cc: "barScriptPadding" vertical space for numbers
span-bar-engraver.cc: "singleStaffBracket" do single staffs get a bracket?
-bar-column-engraver.cc: "barColumnPriority"
-bar-number-engraver.cc: "barNumberBreakPriority" Control horizontal ordering
-mark-engraver.cc: "markBreakPriority" of bars, clefs, keysig
-staff-margin-engraver.cc:"marginBreakPriority" etc. Slated for revision
)
sect(Pre-defined Identifiers)
subsect(Paper variables)
+Warning: this section is outdated and inaccurate.
+
There are a large number of paper variables that are used to control
details of the layout. Usually you will not want to change these
variables; they are set by default to vaules that depend on the font
majority selection is used. If set to 3.0, then mean selection is
used based on the mean center distance. If set to 4.0 then median
selection is used, based on the median center distance.
-dit(code(beam_ideal_stem1))
-dit(code(beam_ideal_stem2))
-dit(code(beam_minimum_stem1))
-dit(code(beam_minimum_stem2))
-dit(code(beam_multiple_break))
-dit(code(beam_slope_damp_correct_factor))
-dit(code(beam_thickness)) Specify the thickness of beams.
dit(code(castingalgorithm))
dit(code(forced_stem_shorten)) Stems that have been forced to go the
unnatural direction are shortened by this amount. Equal to
-code(\interline) by default.
+dit(code(forced_stem_shorten0))
dit(code(gourlay_energybound))
dit(code(gourlay_maxmeasures)) Maximum number of measures per line
when using Gourlay method.
description(
dit(code(Abbreviation_beam_engraver))
-dit(code(Bar_column_engraver))
dit(code(Bar_engraver)) Engraves bar lines. Normally in code(Staff) and
code(RhythmicStaff).
dit(code(Bar_number_engraver)) Engrave bar numbers. These numbers
dit(code(Beam_req_swallow_translator)) Swallows beam requests. In
code(LyricVoice).
+dit(code(Chord_name_engraver)) Engraves chord names. Normally in
+code(ChordNameVoice)
dit(code(Clef_engraver)) Engraves the clef symbol. Normally in code(Staff).
dit(code(Collision_engraver))
dit(code(Dot_column_engraver)) Engraves dots on dotted notes shifted to the
dit(code(Pitch_squash_engraver)) Treat all pitches as middle C. Used in
code(RhythmicStaff). Note that the notes move, but the locations of
accidentals stay the same.
-dit(code(Plet_engraver)) Engraves brackets and the number over tuplets. In
-code(Voice).
-dit(code(Plet_swallow_engraver)) Swallows tuplet requests without any output.
-In code(LyricVoice).
-COMMENT( Should this be named Plet_req_swallow_translator? )
dit(code(Priority_horizontal_align_engraver))
dit(code(Repeat_engraver)) Handles repeats? In code(Staff) and
code(RhythmicStaff).
\time 3/4;
\repeat 2 {
- d4 [g,8 a b c] d4 g, g |
- e'4 [c8 d e fis] g4 g, g |
- c4 [d8( )c b a( ] )b4 [c8 b a g] |
- a4 [b8 a g fis] g2. |
+ d4 g,8 a b c d4 g, g |
+ e'4 c8 d e fis g4 g, g |
+ c4 d8( )c b a( )b4 c8 b a g |
+ a4 b8 a g fis g2. |
}
- b'4 [g8 a b g]
- a4 [d,8 e fis d] |
- g4 [e8 fis g d] cis4 [b8 cis] a4 |
- [a8-. b-. cis-. d-. e-. fis-. ]
+ b'4 g8 a b g
+ a4 d,8 e fis d |
+ g4 e8 fis g d cis4 b8 cis a4 |
+ a8-. b-. cis-. d-. e-. fis-.
g4 fis e |
fis a, r8 cis8
d2.-\fermata
code(c''), the real pitch of this note is code(d''). The 4
designates the duration of the note (it is a quarter note). COMMENT(
-)verb(
- [g,8
-)COMMENT(
-
-)The open bracket starts a beam. Lily can set beams automatically,
-but we want to specify them ourselves. This bracket is connected to the
-following note, which is an eighth with pitch code(g') (remember
-relative mode for pitches!)
-COMMENT(
-
)verb(
a b
)COMMENT(
duration (It is not illegal to enter it anyway. You would then enter
code(a8 b8)) COMMENT(
-)verb(
- c]
-) COMMENT(
-
-) This ends the beam started four notes earlier, at the code(g). In
-the output, you will notice a measure bar following this note. You do
-not have to enter anything to make LilyPond create a bar. Instead
-Lily will deduce where bars have to be by comparing durations of notes with
-the current time signature. COMMENT(
-
)verb(
d4 g, g |
) COMMENT(
music, LilyPond will check that barchecks are found at the start of
a bar. This can help you track down notes you forgot to enter.
verb(
- e'4 [c8 d e fis]
+ e'4 c8 d e fis
) COMMENT(
) So far, no notes were chromatically altered. Here is the first one
sharp sign in the output. The program keeps track of key signatures,
and will only print accidentals if they are needed.
verb(
- c4 [d8( )c b a( ] )b4 [c8 b a g] |
+ c4 d8( )c b a( )b4 c8 b a g |
) COMMENT(
) The next line shows something new: In mudela, one enters a slur by
marking the beginning and ending note of the slur with an opening and
closing parenthesis respectively. In the line shown above this is
done for two slurs. Note that parentheses (slur markers) are between
-the notes, and the brackets (beam markers) around the notes. As you
-can see, the brackets and parentheses do not have to nest.
+the notes. As you can see, parentheses do not have to nest.
verb(
- a4 [b8 a g fis] g2. |
+ a4 b8 a g fis g2. |
) COMMENT(
) A duration that is to be augmented with a duration dot, is notated
) The end of the repeated music. LilyPond will typset a repeat bar.
verb(
- cis'4 [b8 cis] a4 |
+ cis'4 b8 cis a4 |
) COMMENT(
) This line shows that Lily will print an accidental if that is
needed: the first C sharp will be printed with an accidental, the
second one without. COMMENT(
-)verb( [a8-. b-. cis-. d-. e-. fis-. ] % try some super and subscripts.)COMMENT(
+)verb( a8-. b-. cis-. d-. e-. fis-. % try some super and subscripts.)COMMENT(
)There is more to music than just pitches and rhythms. An important
aspect is articulation. You can enter articulation signs either in an
subsect(Chords with names)
-In the previous section we have been talking more about 'stacked notes'
-rather than 'chords'.
+In the previous section we have been talking more about `stacked notes'
+rather than `chords'.
If you need to enter a lot of chords that have proper names, you can use
the code(\chords) mode as an alternative:
COMMENT(
)mudela(fragment,verbatim)(
<
- \type Staff { c''8. c''16 bes'8. a'16 g'4 f'8 g'4. }
+ \type Staff {
+ \property Voice.beamAuto = "0" % no beams in melody
+ c''8. c''16 bes'8. a'16 g'4 f'8 g'4.
+ }
\type Lyrics \lyrics { 'got8. me16 on8. my16 knees,4 Le-8 lie!4. }
>
) COMMENT(
)COMMENT(
)mudela(fragment,verbatim)(<
- \type Staff { c''8. c''16 bes'8. a'16 g'4 f'8 g'4. }
+ \type Staff {
+ \property Voice.beamAuto = "0" % no beams in melody
+ c''8. c''16 bes'8. a'16 g'4 f'8 g'4.
+ }
\type Lyrics \lyrics { 'got8 me8 on8. m$\cal_Y$16 "3s,"4 Le-8 lie!4.}
>
)COMMENT(
Of course, you can also use different ratios, and use beamed notes or
rests:
+COMMENT( BROKEN
+
+lilypond: score-element.cc:134: class Paper_def * Score_element::paper() const: Assertion `pscore_l_' failed.
+
mudela(fragment)(
\type Voice \times 4/5 { [c''8 c''16 c''16] r8 [g'8 g'8] }
)
+)
If you make a tuplet of beamed notes, where the beam is as wide as
the bracket, the bracket is omitted.
AC_STEPMAKE_YODL
AC_STEPMAKE_GUILE
-CXXFLAGS="$CXXFLAGS -fhandle-signatures"
-
dnl should check out -print
dnl huh?
dnl AC_CHECK_SEARCH_RESULT($FIND, find, Please use --enable-tex-dir)
public:
/// check invariants
- void OK() const
- {
- assert (max_ >= size_ && size_ >=0);
- if (max_) assert (array_p_);
- }
+ void OK() const ;
/** report the size_.
@see
{setsize_}
*/
+
int size() const
{
return size_;
// ugh, get around gcc 2.8.1 ice; see bezier.cc
Array (int i)
- {
- max_ = size_ = i;
- array_p_ = new T[i];
- }
+ {
+ max_ = size_ = i;
+ array_p_ = new T[i];
+ }
/** set the size_ to #s#.
{ delete[] array_p_; }
/// return a "new"ed copy of array
- T* copy_array() const
+ T* copy_array() const
{
T* Tarray = new T[size_];
arrcpy (Tarray, array_p_, size_);
return Tarray;
}
- // depracated
- operator T*() const
- {
- return copy_array();
- }
+
void operator=(Array const & src)
{
set_size (src.size_);
}
/// tighten array size_.
- void precompute() {
- remax (size_);
- }
-
- T * remove_array_p () {
- T * p = array_p_;
- size_ = 0;
- max_ = 0;
- array_p_ =0;
- return p;
+ void precompute() {
+ remax (size_);
}
+
+ T * remove_array_p ();
/// access element
T &operator[] (int i)
{
- return elem (i);
+ return elem_ref (i);
}
/// access element
- T const & operator[] (int i) const
+ T const & operator[] (int i) const
{
- return elem (i);
+ return elem_ref (i);
}
/// access element
- T &elem (int i) const
+ T &elem_ref (int i) const
{
assert (i >=0&&i<size_);
return ((T*)array_p_)[i];
}
+ /// access element
+ T elem (int i) const
+ {
+ return elem_ref (i);
+ }
/// add to the end of array
- void push (T x)
+ void push (T x)
{
if (size_ == max_)
remax (2*max_ + 1);
array_p_[size_++] = x;
}
/// remove and return last entry
- T pop()
+ T pop()
{
assert (!empty());
T l = top (0);
return l;
}
/// access last entry
- T& top (int j=0)
+ T& top (int j=0)
{
return (*this)[size_-j-1];
}
/// return last entry
- T top (int j=0) const
+ T top (int j=0) const
{
return (*this)[size_-j-1];
}
(*this)[i]=(*this)[j];
(*this)[j]=t;
}
- bool empty() const
+ bool empty () const
{ return !size_; }
void insert (T k, int j);
return t;
}
void unordered_del (int i)
-
{
- elem (i) = top();
+ elem_ref (i) = top();
set_size (size() -1);
}
void del (int i)
set_size (size_ + src.size_);
arrcpy (array_p_+s,src.array_p_, src.size_);
}
- Array<T> slice (int lower, int upper)
- {
- assert (lower >= 0 && lower <=upper&& upper <= size_);
- Array<T> r;
- int s =upper-lower;
- r.set_size (s);
- arrcpy (r.array_p_, array_p_ + lower, s);
- return r;
- }
+ Array<T> slice (int lower, int upper) ;
void reverse();
};
swap (i,j);
}
+template<class T> INLINE
+void
+Array<T>::OK() const
+{
+ assert (max_ >= size_ && size_ >=0);
+ if (max_) assert (array_p_);
+}
+
+template<class T> INLINE
+T *
+Array<T>::remove_array_p ()
+{
+ T * p = array_p_;
+ size_ = 0;
+ max_ = 0;
+ array_p_ =0;
+ return p;
+}
+
+template<class T> INLINE
+Array<T>
+Array<T>::slice (int lower, int upper)
+{
+ assert (lower >= 0 && lower <=upper&& upper <= size_);
+ Array<T> r;
+ int s =upper-lower;
+ r.set_size (s);
+ arrcpy (r.array_p_, array_p_ + lower, s);
+ return r;
+}
+
#ifndef NDEBUG
if (previous_)
{
- assert (previous_->next_ == this);
+ assert (previous_->next_ == this);
}
if (next_)
{
- assert (next_->previous_ == this);
+ assert (next_->previous_ == this);
}
#endif
}
Link<T>* l = new Link<T>(this, next_, thing);
if (next_)
- next_->previous_ = l;
+ next_->previous_ = l;
next_ = l;
}
// bugfix hwn 16/9/96
Link<T>* l = new Link<T>(previous_, this, thing);
if (previous_)
- previous_->next_ = l;
+ previous_->next_ = l;
previous_ = l;
}
Link<T>::remove (List<T> &l)
{
if (previous_)
- previous_->next_ = next_;
+ previous_->next_ = next_;
else
- l.top_ = next_;
+ l.top_ = next_;
if (next_)
- next_->previous_ = previous_;
+ next_->previous_ = previous_;
else
- l.bottom_ = previous_;
+ l.bottom_ = previous_;
}
template<class T>
an array of pointers.
TODO
- should init to 0. Derive from Array<void*>?
+ should init to 0.
*/
template<class T>
-class Link_array : public Array<T*>
+class Link_array : private Array<void *>
{
static default_compare (T *const& p1, T *const&p2) {
/* can't do p1 -p2, since T might be an incomplete type */
return 1;
return 0;
}
+ Link_array (Array<void*> v)
+ :Array<void*> (v)
+ {
+ }
public:
+ Link_array()
+ {}
+ Link_array (Link_array<T> const &src)
+ : Array<void*> (src)
+ {
+ }
+ /// access element
+ T *elem (int i) const
+ {
+ return elem_ref (i);
+ }
+ T *&elem_ref (int i) const
+ {
+ return (T*&) Array<void*>::elem_ref (i);
+ }
+
+ /// access element
+ T* &operator[] (int i)
+ {
+ return (T*&) Array<void*>::elem_ref (i);
+ }
+ /// access element
+ T *const operator[] (int i) const
+ {
+ return (T *const) Array<void*>::elem (i);
+ }
+ T *pop ()
+ {
+ return (T*) Array<void*>::pop ();
+ }
+ void insert (T *t, int i)
+ {
+ Array<void*>::insert (t, i);
+ }
+ void push (T* t)
+ {
+ Array<void*>::push (t);
+ }
+ /// return last entry
+ T* top (int j=0) const
+ {
+ return (T*) Array<void*>::top (j);
+ }
+ T *& top (int i=0)
+ {
+ return (T*&) Array<void*>::top (i);
+ }
void substitute (T *old, T*new_l)
{
int i;
while ((i = find_i (old)) >=0)
if (new_l)
- elem (i) =new_l;
+ elem_ref (i) =new_l;
else
del (i);
}
int i;
while ((i = find_i (old)) >=0)
if (new_l)
- elem (i) =new_l;
+ elem_ref (i) =new_l;
else {
unordered_del (i);
}
void default_sort() {
sort (default_compare);
}
+ // quicksort.
+ void sort (int (*compare)(T *const&,T *const&),
+ int lower = -1, int upper = -1);
+
void uniq() {
Link_array<T> l_arr;
for (int i=0; i < size(); i++)
l_arr.push (elem (i));
*this = l_arr;
}
-
+ Array<void*>::del;
+ Array<void*>::unordered_del;
+ Array<void*>::size;
+ Array<void*>::clear;
+ Array<void*>::set_size;
+ Array<void*>::empty;
+ Array<void*>::reverse;
+ T * get (int i)
+ {
+ return (T*) Array<void*>::get (i);
+ }
+ Link_array<T>
+ slice(int l,int u)
+ {
+ return Array<void*>::slice (l,u);
+ }
+ void concat (Link_array<T> const &a2)
+ {
+ Array<void*>::concat (a2);
+ }
int find_i (T const * t) const {
for (int i=0; i < size(); i++)
if (elem (i) == t)
else
return 0;
}
+
};
template<class T, class V>
}
+
+template<class T> inline void
+Link_array<T>::sort (int (*compare)(T *const&,T *const&),
+ int lower = -1, int upper = -1)
+{
+ if (lower < 0)
+ {
+ lower = 0 ;
+ upper = size () - 1;
+ }
+ if (lower >= upper)
+ return;
+ swap (lower, (lower+upper)/2);
+ int last = lower;
+ for (int i= lower +1; i <= upper; i++)
+ if (compare (elem (i), elem(lower)) < 0)
+ swap (++last,i);
+ swap (lower, last);
+ sort (compare, lower, last-1);
+ sort (compare, last+1, upper);
+}
+
#endif // PARRAY_HH
--- /dev/null
+%{
+ wierd grouping bug
+%}
+
+\score{
+ \notes \relative c''{
+ % be sure it's not related to auto-beamer
+ \property Voice.beamAuto = "0"
+ \time 1/2;
+ [ c8 c c c ]
+ \time 1/4;
+ [ c8 c ]
+ }
+ \paper{
+ }
+}
--- /dev/null
+\header {
+ filename = "just-friends.ly";
+ title = "Just Friends";
+ description = "Jazz chords example with bar lines";
+ opus = "";
+ source = "mutex@gmd.de";
+ composer = "";
+ enteredby = "jcn";
+ copyright = "Public Domain";
+}
+
+%{
+In response to
+
+Message-Id: <19990206153950.A7474@gil.physik.rwth-aachen.de>
+Date: Sat, 6 Feb 1999 15:39:50 +0100
+From: Christoph Kukulies <kuku@gilberto.physik.RWTH-Aachen.DE>
+Subject: chord bars
+
+I was looking out for a FAQ on the www.gmd.de/Misc/Music page but didn't
+find any so bear with me when asking a FAQ question:
+
+I want to generate some sheets that contain only the chords (changes)
+of a certain tune (Jazz, Real Book, for example), like
+
+ Just Friends
+
+[...]
+
+%}
+
+\score{
+ \type ChordNames \chords{
+ \property Score.chordInversion = 1
+ \property Score.barAtLineStart = 1
+ \repeat 2 {
+ f1-maj f-maj f-7 bes-7
+ c-maj c-maj es es
+ d-7 g-7 b2-7/fis e-7 a1-7\break
+ d-7 d-7 d-7 g2-7 ges-7
+
+ f1-maj f1-maj f-7 bes-7
+ c-maj c-maj es es
+ d-7 g-7 b2-7/fis e-7 a1-7\break
+ d-7 d2-7 g-7 c1-6 g2-7 c-7
+ }
+ }
+ \paper{
+ indent = 0.0\mm;
+ linewidth = 100.0\mm;
+ \translator{
+ \ChordNameContext
+ barAuto = "1";
+ \consists Bar_engraver;
+ \consists "Repeat_engraver";
+ }
+ }
+}
>
\paper{
\translator { \OrchestralScoreContext }
- \translator {
- \VoiceContext
- \consists Auto_beam_engraver;
- beamAuto = 1.;
- beamAutoEnd = "3/8";
- }
}
\midi{ \tempo 4 = 160; }
}
\translator {
\BarNumberingStaffContext
}
- \translator{
- \VoiceContext
- \consists Auto_beam_engraver;
- beamAuto = 1.;
- beamAutoEnd8 = "1/4";
- beamAutoEnd16 = "1/4";
- }
}
}
--- /dev/null
+%{
+ Currently (1.1.27.jcn3), the auto-beam engraver will only engrave
+ sensible beams, which means that it will end a beam when:
+ * a rest is encountered
+ * another beam (entered manually) is encountered
+ * there's a 'gap' in the beam note's durations
+
+ The beam will be ended also when
+
+ now / beamAutoEnd = 0
+%}
+
+\score{
+ \notes \relative c''{
+ \time 2/4;
+ % one beam per measure
+ c8 c c c
+ c16 c c c c c c c
+ % from here on consider ending beam every 1/4 note
+ \property Voice.beamAutoEnd = "1/4"
+ c8 c c c
+ % manually override autobeam with weird beaming
+ c8 [c c] c
+ c8 c c r
+ c8 c c4
+ r8 c c c
+ % no autobeaming
+ \property Voice.beamAuto = "0"
+ c8 c c c
+ }
+ \paper{
+ \translator{
+ \VoiceContext
+ % consider ending beam at every 1/2 note
+ beamAutoEnd = "1/2";
+ }
+ }
+}
%{
- Currently (1.1.22.jcn5), the auto-beam engraver will only engrave
- sensible beams (hopefully), which means that it will give up the
- whole beam if:
- * a rest is encountered
- * another beam (entered manually) is encountered
- * there's a 'gap' in the beam note's durations
-
- There's no smart algorithm, beginning a beam is considered when
-
- now / beamAutoBegin = 0
-
- the beam will be ended when
-
- * now / beamAutoEnd = 0
+ The auto-beam engraver has presets for common time signatures.
%}
-
+
\score{
\notes \relative c''{
- \time 2/4;
- % one beam per measure
- c8 c c c
- c16 c c c c c c c
- % from here on two beams per measure
- \property Voice.beamAutoEnd = "1/4";
- c8 c c c
- % manually override autobeam with weird beaming
- c8 [c c] c
- c8 c c r
- c8 c c4
- r8 c c c
- % no autobeaming
- \property Voice.beamAuto = "0"
- c8 c c c
+%{
+ % urg: something breaks in grouping ; see input/bugs/time-grouping.ly
+ \time 1/2;
+ c8 c c c
+ c16 c c c c c c c
+ c32 c c c c c c c c c c c c c c c
+ \time 1/4;
+ c8 c
+ c16 c c c
+ c32 c c c c c c c
+ \time 1/8;
+ c8
+ c16 c
+ c32 c c c
+%}
+ \time 2/2;
+ c8 c c c c c c c
+ c16 c c c c c c c c c c c c c c c
+ c32 c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c
+ \time 2/4;
+ c8 c c c
+ c16 c c c c c c c
+ c32 c c c c c c c c c c c c c c c
+ \time 2/8;
+ c8 c
+ c16 c c c
+ c32 c c c c c c c
+ \time 3/2;
+ c8 c c c c c c c c c c c
+ c16 c c c c c c c c c c c c c c c c c c c c c c c
+ \time 3/4;
+ c8 c c c c c
+ c16 c c c c c c c c c c c
+ c32 c c c c c c c c c c c c c c c c c c c c c c c
+ \time 3/8;
+ c8 c c
+ c16 c c c c c
+ c32 c c c c c c c c c c c
+ \time 4/4;
+ c8 c c c c c c c
+ c16 c c c c c c c c c c c c c c c
+ c32 c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c
+ \time 4/8;
+ c8 c c c
+ c16 c c c c c c c
+ c32 c c c c c c c c c c c c c c c
+ \time 6/8;
+ c8 c c c c c
+ c16 c c c c c c c c c c c
+ \time 9/8;
+ c8 c c c c c c c c
+ c16 c c c c c c c c c c c c c c c c c
}
\paper{
- \translator{
- \VoiceContext
- % add experimental auto-beaming
- \consists Auto_beam_engraver;
- % switch it on (perhaps a bit double, but we want to be able
- % to switch it off conveniently
- beamAuto = 1.;
- % consider starting beam at every 4 note
- % beamAutoBegin = "1/4";
- beamAutoEnd = "1/2";
- }
}
}
c1 c-sus c-6 c/e c/g c/d
% now try to find chords with inversions
\property Score.chordInversion = 1
- \property Score.chordInversionPreserve = 1
c1 c-sus c-6
- c/e % c/e is not found because preserving doesn't work fully yet...
+ c/e
c/g
c/d % this triggers a warning: no 'd' in chord of c
}
}
tab = \notes\transpose c'''\chords{
- c1 c-m c-4 c-m4 c-5+ c-5- c-m5- c-5.5+ c-6\break %c-m6\break
+ c1 c-m c-4 c-m4 c-5+ c-5- c-m5- c-5-.5+ c-6\break %c-m6\break
}
\score{
--- /dev/null
+%{
+Hi,
+ I want to write some music that has the structure:
+
+ Intro
+ \repeat 4 { Chorus [first-ending] verse }
+ fifth-ending final
+
+ The obvious:
+
+ \repeat 4 { Chorus \alternative{{first-ending}{}} verse}
+ \alternative{{}{fifth-ending}}
+ final
+
+ doesn't work.
+
+ And the (logically correct but ugly)
+
+ \repeat 4 {Chorus}
+ \alternative {{first-ending verse}{fifth ending}}
+ final
+
+ is very ugly, because the volta bracket keeps going for so
+ long.
+
+ Peter C
+%}
+
+\score{
+ <
+ \type Staff \notes\relative c''{
+ c c c c
+ % coda-klugde: let volta span only one bar
+ \property Staff.voltaSpannerDuration = "1"
+ \repeat 5 { d d d d }
+ \alternative { { e e e e f f f f }
+ { g g g g } }
+ }
+ \type Lyrics \lyrics{
+ intro1
+ \repeat 5 {}
+ \alternative <
+ { chorus1 one verse1 }
+ { chorus1 two verse1 }
+ { chorus1 three verse }
+ { chorus1 four verse }
+ >
+ five1
+ }
+ >
+}
+
--- /dev/null
+
+%{
+ Test ly2dvi features.
+%}
+
+\header {
+copyright = "copyright";
+title = "title";
+subtitle = "subtitle";
+composer = "composer";
+arranger = "arranger";
+instrument = "instrument";
+metre = "metre";
+opus = "opus";
+piece = "piece";
+poet = "poet";
+}
+
+
+\score {
+ \notes { c1 c1 c1 c1 }
+}
+
+\score {
+ \notes { c1 c1 c1 c1 }
+
+ \header {
+
+ title = "localtitle";
+ subtitle = "localsubtitle";
+ composer = "localcomposer";
+ arranger = "localarranger";
+ instrument = "localinstrument";
+ metre = "localmetre";
+ opus = "localopus";
+ piece = "localpiece";
+ poet = "localpoet";
+ copyright = "localcopyright";
+ }
+}
<
\type Staff \notes\relative c'{
c4 d e f
- \repeat 2 { g a b c }
+ \repeat 3 { g a b c }
% \alternative { { c b a g } { f e d c } } c c c c
\alternative { { c b a g } { f e d c } { c d e f } }
g g g g
--- /dev/null
+
+\version "1.0.14";
+nt = \notes { c1 \break c1 c1 }
+stuff = \notes \relative c'' <
+ \type Staff = stone { \nt }
+ \type Staff = sttwo { \nt }
+>
+
+\score{
+ \type StaffGroup \stuff
+}
+
+\score{
+ \type StaffGroup < \type GrandStaff \stuff
+ \type Staff = stthree \nt
+ >
+}
+
+\score{
+ \type ChoirStaff \stuff
+}
+
+
Duration dur = mom2standardised_dur (mom);
// if (!dur.mom () || (dur.mom () == mom))
- if (!dur.length () || (dur.length () == mom))
+ if (!dur.length_mom () || (dur.length_mom () == mom))
return dur;
assert (midi_as_plet_b_s);
// dur.set_plet (type_mom, Duration::division_1_i_s / 4);
// Moment as_plet_mom = mom / dur.mom ();
- Moment as_plet_mom = mom / dur.length ();
+ Moment as_plet_mom = mom / dur.length_mom ();
as_plet_mom *= dur.plet_.mom ();
long num = as_plet_mom.num ();
long den = as_plet_mom.den ();
Duration dur = mom2standardised_dur (mom);
- if (dur.length () == mom)
+ if (dur.length_mom () == mom)
return dur;
return mom2_dur (mom);
plet_.type_i_ *= m.den_i ();
}
-// ugh, what's this?
-// i should be called "mom ()", ... or at least "length_mom ()"
Moment
-Duration::length () const
+Duration::length_mom () const
{
return Duration_convert::dur2_mom (*this);
}
static bool duration_type_b (int t);
void set_ticks (int ticks_i );
- Moment length () const ; // zo naai mij
+ Moment length_mom () const ;
static int division_1_i_s;
/// Logarithm of the base duration.
MODULE_LIBS=$(depth)/lib $(depth)/flower
MODULE_INCLUDES=$(depth)/lib/include $(depth)/flower/include
+MODULE_CXXFLAGS=
+
+
STEPMAKE_TEMPLATES= c++ executable po
#include "paper-def.hh"
#include "lookup.hh"
#include "stem.hh"
+#include "offset.hh"
Abbreviation::Abbreviation ()
{
}
Real sl = slope_f * internote_f;
- Atom a (lookup_l ()->beam (sl, w, beam_f));
+ Molecule a (lookup_l ()->beam (sl, w, beam_f));
a.translate (Offset (-w/2, w / 2 * slope_f));
Molecule *beams= new Molecule;
for (int i = 0; i < abbrev_flags_i_; i++)
{
- Atom b (a);
+ Molecule b (a);
b.translate_axis (interbeam_f * i, Y_AXIS);
- beams->add_atom (b);
+ beams->add_molecule (b);
}
beams->translate_axis (-beams->extent ()[Y_AXIS].center (), Y_AXIS);
#include "abbreviation-beam.hh"
#include "misc.hh"
#include "debug.hh"
-#include "atom.hh"
+
#include "molecule.hh"
#include "leastsquares.hh"
#include "stem.hh"
#include "dimensions.hh"
#include "lookup.hh"
#include "main.hh"
+#include "global-ctor.hh"
-inline bool
-Atom::check_infinity_b ()const
+Atom::Atom(SCM s)
{
- bool ridiculous = false;
-
-#ifndef NDEBUG
- /* infinity checks. */
- for (int a = X_AXIS; a < NO_AXES; a++)
- {
- Axis ax = (Axis)a;
- if (abs (off_[ax]) >= 100 CM)
- {
- warning (_f ("ridiculous dimension: %s, %s", axis_name_str (ax),
- print_dimen (off_[ax])));
-
- if (experimental_features_global_b)
- assert (false);
-
- ( (Atom*)this)->off_[ax] = 0.0;
- ridiculous = true;
- }
- }
-#endif
- return ridiculous;
+ func_ = s;
}
-void
-Atom::print () const
+#if 0
+int
+Atom::smob_display (SCM smob, SCM port, scm_print_state*)
{
-#ifndef NPRINT
- DOUT << "string: " << str_ << '\n';
-
- DOUT << "dim:";
- for (Axis i=X_AXIS; i < NO_AXES; incr (i))
- DOUT << axis_name_str (i) << " = " << dim_[i].str ();
+ Atom* a =(Atom*) SCM_CDR(smob);
+ String i (a->off_.str ());
+
+ scm_puts ("#<Atom ", port);
+ scm_puts (i.ch_C(), port);
+ gh_display (a->func_);
+ scm_puts (">", port);
- DOUT << "\noffset: " << off_.str ();
-#endif
+ /* non-zero means success */
+ return 1;
}
-Box
-Atom::extent () const
+
+scm_sizet
+Atom::smob_free (SCM smob)
{
- Box b (dim_);
- b.translate (off_);
- return b;
+ Atom * a= (Atom*) SCM_CDR(smob);
+ delete a;
+ return sizeof (Atom);
}
-Interval
-Atom::extent (Axis a) const
+SCM
+Atom::smob_mark (SCM smob)
{
- return dim_[a] + off_[a];
+ Atom * a= (Atom*) SCM_CDR(smob);
+ scm_gc_mark (a->func_);
+ return a->font_;
}
+long Atom::smob_tag_;
-
-Atom::Atom ()
- : dim_ (Interval (0,0),Interval (0,0))
+void
+Atom::init_smob ()
{
- str_ = "unknown\n";
- origin_l_ = 0;
-}
+ static scm_smobfuns type_rec;
-Atom::Atom (String s, Box b)
- : dim_ (b)
-{
- str_ = s;
- origin_l_ = 0;
+ type_rec.mark = smob_mark;
+ type_rec.free = smob_free;
+ type_rec.print = smob_display;
+ type_rec.equalp = 0;
+
+ smob_tag_ = scm_newsmob (&type_rec);
}
-String
-Atom::str () const
+SCM
+Atom::make_smob () const
{
- return String ("Atom (\'") + str_ + "\', (" + dim_.x ().str () + ", "
- + dim_.y ().str () + "))";
+ SCM smob;
+ SCM_NEWCELL (smob);
+ SCM_SETCAR (smob, smob_tag_);
+ SCM_SETCDR (smob, this);
+ return smob;
}
-Offset
-Atom::offset () const
+SCM
+Atom::make_atom (SCM outputfunc)
{
- check_infinity_b ();
- return off_;
+ Atom * a= new Atom(outputfunc);
+ return a->make_smob ();
}
-void
-Atom::translate_axis (Real r, Axis a)
+SCM
+Atom::copy_self () const
{
- off_[a] += r;
- check_infinity_b ();
+ return (new Atom (*this))->make_smob ();
}
-void
-Atom::translate (Offset o)
+bool
+Atom::Atom_b (SCM obj)
{
- off_ += o;
- check_infinity_b ();
+ return(SCM_NIMP(obj) && SCM_CAR(obj) == smob_tag_);
}
-bool
-Atom::empty() const
+Atom*
+Atom::atom_l (SCM a)
{
- return (dim_.y().length() == 0);
+ assert (Atom_b (a));
+ return (Atom*) SCM_CDR(a);
}
+
+
+ADD_GLOBAL_CTOR_WITHNAME(atomsmob, Atom::init_smob);
+#endif
+
+
#include "musical-request.hh"
#include "bar.hh"
#include "beam.hh"
-#include "grouping.hh"
+#include "rhythmic-grouping.hh"
#include "rest.hh"
#include "stem.hh"
#include "debug.hh"
Auto_beam_engraver::Auto_beam_engraver ()
{
beam_p_ = 0;
+ mult_i_ = 0;
finished_beam_p_ = 0;
finished_grouping_p_ = 0;
grouping_p_ = 0;
Auto_beam_engraver::consider_end_and_begin ()
{
Time_description const *time = get_staff_info().time_C_;
+ int num = time->whole_per_measure_ / time->one_beat_;
+ int den = time->one_beat_.den_i ();
+ String time_str = String ("time") + to_str (num) + "_" + to_str (den);
+ int type = 1 << (mult_i_ + 2);
+ String type_str = to_str (type);
+
+ /*
+ Determine end moment for auto beaming (and begin, mostly 0==anywhere)
+ In order of increasing priority:
+
+ i. every beat <den>
+ ii. time<num>_<den>beamAutoEnd
+ iii. time<num>_<den>beamAutoEnd<type>
+ iv. beamAutoEnd
+ v. beamAutoEnd<type>
+
+
+ Rationale:
+
+ [to be defined in config file]
+ i. easy catch-all rule
+ ii. exceptions for time signature
+ iii. exceptions for time signature, for specific duration type
- Scalar begin = get_property ("beamAutoBegin", 0);
- Moment begin_mom = begin.to_rat ();
+ [user override]
+ iv. generic override
+ v. override for specific duration type
+
+ The user overrides should be required for common cases.
+ */
- Scalar end = get_property ("beamAutoEnd", 0);
- Moment end_mom = end.to_rat ();
+ /*
+ first guess: begin beam at any position
+ */
+ Moment begin_mom (0);
+ /*
+ first guess: end beam at end of beat
+ */
+ Moment end_mom = time->one_beat_;
+
+ /*
+ second guess: property generic time exception
+ */
+ Scalar begin = get_property (time_str + "beamAutoBegin", 0);
+ if (begin.length_i ())
+ begin_mom = begin.to_rat ();
+ Scalar end = get_property (time_str + "beamAutoEnd", 0);
+ if (end.length_i ())
+ end_mom = end.to_rat ();
+
+ /*
+ third guess: property time exception, specific for duration type
+ */
+ if (mult_i_)
+ {
+ Scalar end_mult = get_property (time_str + "beamAutoEnd" + type_str, 0);
+ if (end_mult.length_i ())
+ end_mom = end_mult.to_rat ();
+ Scalar begin_mult = get_property (time_str + "beamAutoBegin" + type_str, 0);
+ if (begin_mult.length_i ())
+ begin_mom = begin_mult.to_rat ();
+ }
+
+ /*
+ fourth guess [user override]: property plain generic
+ */
+ begin = get_property ("beamAutoBegin", 0);
+ if (begin.length_i ())
+ begin_mom = begin.to_rat ();
+
+ end = get_property ("beamAutoEnd", 0);
+ if (end.length_i ())
+ end_mom = end.to_rat ();
+
+ /*
+ fifth guess [user override]: property plain, specific for duration type
+ */
if (mult_i_)
{
- int type = 1 << (mult_i_ + 2);
- Scalar end_mult = get_property (String ("beamAutoEnd")
- + to_str (type), 0);
+ Scalar end_mult = get_property (String ("beamAutoEnd") + type_str, 0);
if (end_mult.length_i ())
end_mom = end_mult.to_rat ();
- else if (Moment (type, 4) / end_mom > Moment (4))
- end_mom /= Moment (type, 8);
+ Scalar begin_mult = get_property (String ("beamAutoBegin") + type_str, 0);
+ if (begin_mult.length_i ())
+ begin_mom = begin_mult.to_rat ();
}
Real f;
void
Auto_beam_engraver::begin_beam ()
{
- DOUT << String ("starting autobeam at: ") + now_moment ().str () + "\n";
+ DOUT << String ("starting autobeam at: ") + now_mom ().str () + "\n";
beam_p_ = new Beam;
grouping_p_ = new Rhythmic_grouping;
void
Auto_beam_engraver::end_beam ()
{
- DOUT << String ("ending autobeam at: ") + now_moment ().str () + "\n";
+ DOUT << String ("ending autobeam at: ") + now_mom ().str () + "\n";
if (beam_p_->stems_.size () < 2)
{
DOUT << "junking autombeam: less than two stems\n";
consider_end_and_begin ();
}
mult_i_ = m;
- grouping_p_->add_child (start, rhythmic_req->duration ());
+ grouping_p_->add_child (start, rhythmic_req->length_mom ());
stem_l->flag_i_ = rhythmic_req->duration_.durlog_i_;
beam_p_->add_stem (stem_l);
- Moment now = now_moment ();
+ Moment now = now_mom ();
last_add_mom_ = now;
- extend_mom_ = extend_mom_ >? now + rhythmic_req->duration ();
+ extend_mom_ = extend_mom_ >? now + rhythmic_req->length_mom ();
}
}
}
{
if (beam_p_)
{
- Moment now = now_moment ();
+ Moment now = now_mom ();
if ((extend_mom_ < now)
|| ((extend_mom_ == now) && (last_add_mom_ != now )))
{
{
bar_p_->type_str_ = default_type;
}
+ Scalar prop = get_property ("barAtLineStart", 0);
+ if (prop.to_bool ())
+ {
+ bar_p_->at_line_start_b_ = true;
+ }
announce_element (Score_element_info (bar_p_, bar_req_l_));
}
}
void
Bar_engraver::request_bar (String type_str)
{
+ Scalar prop = get_property ("barAtLineStart", 0);
+ if (!now_mom ())
+ {
+ Scalar prop = get_property ("barAtLineStart", 0);
+ if (!prop.to_bool ())
+ return;
+ }
create_bar ();
if (((type_str == "|:") && (bar_p_->type_str_ == ":|"))
|| ((type_str == ":|") && (bar_p_->type_str_ == "|:")))
create_bar ();
bar_p_->type_str_ = bar_req_l_->type_str_;
}
- else if (!now_moment ())
+ else if (!now_mom ())
{
create_bar ();
- bar_p_->type_str_ = "";
+ bar_p_->type_str_ = "|";
}
else
{
axis_ = Y_AXIS;
type_ = "barNumber";
visibility_lambda_
- = gh_eval_str ("(lambda (d) (if (= d 1) '(#f . #f) '(#t . #t)))");
+ = gh_eval_str ("postbreak_only_visibility");
}
void
Timing_translator *timer = dynamic_cast<Timing_translator*>(tr);
Time_description *time = &timer->time_;
- if (!time->whole_in_measure_ && !time->cadenza_b_ && now_moment () > Moment (0))
+ if (!time->whole_in_measure_ && !time->cadenza_b_ && now_mom () > Moment (0))
{
create_items (0);
staff_side_p_ = 0;
text_p_ =0;
visibility_lambda_
- = gh_eval_str ("(lambda (d) (if (= d -1) '(#t . #t) '(#f . #f)))");
+ = gh_eval_str ("non_postbreak_visibility");
}
void
{
breakable_b_ = true;
type_str_ = "|";
+ at_line_start_b_ = false;
}
void
{":|", ":|", ""},
{"||", "||", ""},
{".|.", ".|.", ""},
+ {"", "scorebar", "|"},
+ {"", "{", "{"},
+ {"", "[", "["},
{0,0,0}
};
for (int i=0; bar_breaks[i][0]; i++)
{
if (bar_breaks[i][1] == type_str_)
- type_str_ = bar_breaks[i][break_status_dir ()+1];
+ {
+ type_str_ = bar_breaks[i][break_status_dir ()+1];
+ if (at_line_start_b_ && (break_status_dir_ == 1) && (type_str_ == ""))
+ {
+ type_str_ = "|";
+ }
+ }
}
/*
--- /dev/null
+/*
+ span-bar-grav.cc -- implement Base_span_bar_engraver
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+*/
+
+#include "span-bar.hh"
+#include "base-span-bar-engraver.hh"
+#include "vertical-align-spanner.hh"
+
+Base_span_bar_engraver::Base_span_bar_engraver()
+{
+ spanbar_p_ =0;
+ valign_l_ =0;
+ use_priority_b_ = true;
+ break_priority_i_ = 0;
+}
+
+Span_bar*
+Base_span_bar_engraver::get_span_bar_p() const
+{
+ return new Span_bar;
+}
+
+
+void
+Base_span_bar_engraver::acknowledge_element (Score_element_info i)
+{
+ int depth = i.origin_grav_l_arr_.size();
+ if (depth > 1
+ && dynamic_cast<Bar *> (i.elem_l_))
+ {
+ bar_l_arr_.push (dynamic_cast<Bar *> (i.elem_l_));
+
+ if (bar_l_arr_.size() >= 2 && !spanbar_p_)
+ /*
+ hmm, i do want a bracket with one staff some times, but not always
+ if (bar_l_arr_.size() >= 1 && !spanbar_p_)
+
+ --jcn
+ */
+
+ /*
+
+ use a property? get_property ("singleStaffBracket", 0) ?
+
+ --hwn
+ */
+ {
+ spanbar_p_ = get_span_bar_p();
+
+ if (use_priority_b_)
+ {
+ spanbar_p_->break_priority_i_ = break_priority_i_;
+ }
+ else
+ {
+ spanbar_p_->dim_cache_[X_AXIS].parent_l_ = &bar_l_arr_[0]->dim_cache_[X_AXIS];
+ }
+
+ announce_element (Score_element_info (spanbar_p_,0));
+ if (spanbar_p_->type_str_.empty_b ())
+ spanbar_p_-> type_str_ = bar_l_arr_[0]->type_str_;
+ }
+ }
+ else if (dynamic_cast<Vertical_align_spanner *> (i.elem_l_)
+ && i.origin_grav_l_arr_.size() <= 2)
+ {
+ valign_l_ = dynamic_cast<Vertical_align_spanner *> (i.elem_l_);
+ }
+}
+
+void
+Base_span_bar_engraver::do_pre_move_processing()
+{
+ if (spanbar_p_)
+ {
+ for (int i=0; i < bar_l_arr_.size() ; i++)
+ spanbar_p_->add_bar (bar_l_arr_[i]);
+ spanbar_p_->set_align (valign_l_);
+ typeset_element (spanbar_p_);
+ spanbar_p_ =0;
+ }
+ bar_l_arr_.set_size (0);
+}
+
+
+
+ADD_THIS_TRANSLATOR(Base_span_bar_engraver);
#include "beam-engraver.hh"
#include "musical-request.hh"
#include "beam.hh"
-#include "grouping.hh"
+#include "rhythmic-grouping.hh"
#include "stem.hh"
#include "warn.hh"
#include "time-description.hh"
finished_grouping_p_ = 0;
grouping_p_ =0;
reqs_drul_[LEFT] = reqs_drul_[RIGHT] =0;
+ prev_start_req_ =0;
}
bool
{
if (!beam_p_)
reqs_drul_[STOP]->warning (_("No beam to end"));
+ prev_start_req_ =0;
finished_beam_p_ = beam_p_;
finished_grouping_p_ = grouping_p_;
void
Beam_engraver::do_post_move_processing ()
{
- reqs_drul_ [START] =0;
+ if (reqs_drul_[START])
+ {
+ prev_start_req_ = reqs_drul_[START];
+ reqs_drul_ [START] =0;
+ }
}
void
typeset_beam ();
if (beam_p_)
{
- warning (_ ("Unfinished beam"));
+ prev_start_req_->warning (_ ("Unfinished beam"));
finished_beam_p_ = beam_p_;
finished_grouping_p_ = grouping_p_;
typeset_beam ();
if (!grouping_p_->child_fit_b (start))
{
String s (_ ("please fix me") + ": "
- + _f ("stem at %s doesn't fit in beam", now_moment ().str ()));
+ + _f ("stem at %s doesn't fit in beam", now_mom ().str ()));
if (info.req_l_)
info.req_l_->warning(s);
}
else
{
- grouping_p_->add_child (start, rhythmic_req->duration ());
+ grouping_p_->add_child (start, rhythmic_req->length_mom ());
stem_l->flag_i_ = rhythmic_req->duration_.durlog_i_;
beam_p_->add_stem (stem_l);
}
#include "abbreviation-beam.hh"
#include "misc.hh"
#include "debug.hh"
-#include "atom.hh"
+
#include "molecule.hh"
#include "leastsquares.hh"
#include "stem.hh"
#include "paper-def.hh"
#include "lookup.hh"
-#include "grouping.hh"
+#include "rhythmic-grouping.hh"
Beam::Beam ()
{
*/
Real w = here->hpos_f () - prev->hpos_f ();
w = w/2 <? nw_f;
- Atom a;
+ Molecule a;
if (lhalfs) // generates warnings if not
a = lookup_l ()->beam (sl, w, beam_f);
a.translate (Offset (-w, -w * sl));
for (int j = 0; j < lhalfs; j++)
{
- Atom b (a);
+ Molecule b (a);
b.translate_axis (-dir_ * dy * (lwholebeams+j), Y_AXIS);
- leftbeams.add_atom (b);
+ leftbeams.add_molecule (b);
}
}
int rwholebeams = here->beams_i_drul_[RIGHT] <? next->beams_i_drul_[LEFT];
Real w = next->hpos_f () - here->hpos_f ();
- Atom a = lookup_l ()->beam (sl, w + stemdx, beam_f);
+ Molecule a = lookup_l ()->beam (sl, w + stemdx, beam_f);
a.translate_axis( - stemdx/2, X_AXIS);
int j = 0;
Real gap_f = 0;
int nogap = rwholebeams - here->beam_gap_i_;
for (; j < nogap; j++)
{
- Atom b (a);
+ Molecule b (a);
b.translate_axis (-dir_ * dy * j, Y_AXIS);
- rightbeams.add_atom (b);
+ rightbeams.add_molecule (b);
}
// TODO: notehead widths differ for different types
gap_f = nw_f / 2;
for (; j < rwholebeams; j++)
{
- Atom b (a);
+ Molecule b (a);
b.translate (Offset (gap_f, -dir_ * dy * j));
- rightbeams.add_atom (b);
+ rightbeams.add_molecule (b);
}
w = w/2 <? nw_f;
for (; j < rwholebeams + rhalfs; j++)
{
- Atom b (a);
+ Molecule b (a);
b.translate_axis (-dir_ * dy * j, Y_AXIS);
- rightbeams.add_atom (b);
+ rightbeams.add_molecule (b);
}
}
Real thick = paper ()->get_var ("slur_thickness");
Array<Offset> c = get_controls ();
Real dy = c[3].y () - c[0].y ();
- Atom a;
+ Molecule a;
if (!dash_i_)
a = lookup_l ()->slur (c);
a.translate (Offset (dx_f_drul_[LEFT], dy_f_drul_[LEFT]));
Molecule* mol_p = new Molecule;
- mol_p->add_atom (a);
+ mol_p->add_molecule (a);
mol_p->translate_axis (-interstaff_f_, Y_AXIS);
return mol_p;
{
}
+void
+Box::set_empty ()
+{
+ interval_a_[X_AXIS].set_empty ();
+ interval_a_[Y_AXIS].set_empty ();
+}
+
Box::Box (Interval ix, Interval iy)
{
x() = ix;
Line_spacer*
Break_algorithm::generate_spacing_problem (Line_of_cols curline, Interval line) const
{
- Spring_spacer * sp= (Spring_spacer*) (*get_line_spacer) (); // ugh
+ // ugh
+ Spring_spacer * sp= dynamic_cast<Spring_spacer*> ((*get_line_spacer) ());
sp->paper_l_ = pscore_l_->paper_l_;
sp->add_column (curline[0], true, line[LEFT]);
for (int i=0; i < curline.size (); i++)
{
if (i && i < curline.size () -1
- && (((Score_column*)curline[i])->break_penalty_i () >= Break_req::FORCE))
+ && ((dynamic_cast<Score_column*>(curline[i]))->break_penalty_i () >= Break_req::FORCE))
return false;
}
return true;
void
Change_iterator::error (String reason)
{
- String to_type = change_l ()->change_to_type_str_;
- String to_id = change_l ()->change_to_id_str_;
+ Change_translator const * t = dynamic_cast<Change_translator const*> (music_l_);
+ String to_type = t->change_to_type_str_;
+ String to_id = t->change_to_id_str_;
String warn1 = _f ("can't change `%s\' to `%s\'", to_type, to_id)
+ ": " + reason;
+ report_to_l ()->type_str_ + " = `"
+ report_to_l ()->id_str_ + "\': ";
warning (warn2);
- change_l ()->warning (warn1);
-}
-
-Change_translator *
-Change_iterator::change_l ()
-{
- return (Change_translator*) music_l_;
+ t->warning (warn1);
}
/*
Translator_group * current = report_to_l ();
Translator_group * last = 0;
- String to_type = change_l ()->change_to_type_str_;
- String to_id = change_l ()->change_to_id_str_;
+ Change_translator const * t = dynamic_cast<Change_translator const*> (music_l_);
+ String to_type = t->change_to_type_str_;
+ String to_id = t->change_to_id_str_;
/* find the type of translator that we're changing.
source file of the GNU LilyPond music typesetter
- (c) 1998 Jan Nieuwenhuizen <janneke@gnu.org>
+ (c) 1998, 1999 Jan Nieuwenhuizen <janneke@gnu.org>
*/
#include "chord-name-engraver.hh"
Chord_name_engraver::Chord_name_engraver ()
{
+ tonic_req_ = 0;
}
void
pitch_arr_.push (n->pitch_);
return true;
}
+ if (Tonic_req* t = dynamic_cast<Tonic_req*> (m))
+ {
+ tonic_req_ = t;
+ return true;
+ }
return false;
}
if (!pitch_arr_.size ())
return;
- /*
- Banter style chord names (almost).
- TODO:
- - move this stuff to new Item class Chord_name
- - switch on property, add american (?) chordNameStyle
-
- Scalar chordNameStyle = get_property ("chordNameStyle", 0);
- if (chordNameStyle == "Banter")
- chord = pitches_to_banter (pitch_arr_));
-
- */
-
Chord chord (pitch_arr_);
Musical_pitch* inversion = 0;
Scalar chord_inversion = get_property ("chordInversion", 0);
if (chord_inversion.to_bool ())
{
- int tonic_i = chord.find_tonic_i ();
+ int tonic_i = tonic_req_
+ ? chord.find_notename_i (tonic_req_->pitch_) : chord.find_tonic_i ();
+
if (tonic_i)
{
inversion = &pitch_arr_[0];
- Scalar preserve = get_property ("chordInversionPreserve", 0);
- if (preserve.to_bool ())
- chord.rebuild_from_base (tonic_i);
- else
- chord.rebuild_insert_inversion (tonic_i);
+ chord.rebuild_insert_inversion (tonic_i);
}
}
G_text_item* item_p = new G_text_item;
+ /*
+ TODO:
+ - switch on property, add american (?) chordNameStyle:
+ Chord::american_str (...)
+
+ Scalar chordNameStyle = get_property ("chordNameStyle", 0);
+ if (chordNameStyle == "Banter")
+ item_p->text_str_ = chord.banter_str (inversion);
+ */
+
item_p->text_str_ = chord.banter_str (inversion);
Scalar style = get_property ("textstyle", 0);
}
text_p_arr_.clear ();
pitch_arr_.clear ();
+ tonic_req_ = 0;
}
#include "chord.hh"
#include "warn.hh"
+// doesn't seem common, and we should know about this during purple hit
+// #define INVERSION_ADDED_AS_BASE 1
+
Chord::Chord (Array<Musical_pitch> pitch_arr)
{
pitch_arr_ = pitch_arr;
}
-// construct from parser output
-// urg: should split this up into understandable chunks
-Chord::Chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p)
+static void
+rebuild_transpose (Musical_pitch tonic, Array<Musical_pitch>* pitch_arr_p)
{
- for (int i = 0; i < add_arr_p->size (); i++)
+ for (int i = 0; i < pitch_arr_p->size (); i++)
{
Musical_pitch p = tonic;
- Musical_pitch q = (*add_arr_p)[i];
+ Musical_pitch q = (*pitch_arr_p)[i];
// duh, c7 should mean <c bes>
if (q.notename_i_ == 6)
q.accidental_i_--;
p.transpose (q);
- (*add_arr_p)[i] = p;
+ (*pitch_arr_p)[i] = p;
}
- add_arr_p->sort (Musical_pitch::compare);
- for (int i = 0; i < sub_arr_p->size (); i++)
+ pitch_arr_p->sort (Musical_pitch::compare);
+}
+
+static int
+find_pitch_i (Array<Musical_pitch> const* pitch_arr_p, Musical_pitch p)
+{
+ for (int i = 0; i < pitch_arr_p->size (); i++)
+ if (p == (*pitch_arr_p)[i])
+ return i;
+ return -1;
+}
+
+static int
+find_notename_i (Array<Musical_pitch> const* pitch_arr_p, Musical_pitch p)
+{
+ int i = find_pitch_i (pitch_arr_p, p);
+ if (i == -1)
{
- Musical_pitch p = tonic;
- Musical_pitch q = (*sub_arr_p)[i];
- // duh, c7 should mean <c bes>
- if (q.notename_i_ == 6)
- q.accidental_i_--;
- p.transpose (q);
- (*sub_arr_p)[i] = p;
+ for (int i = 0; i < pitch_arr_p->size (); i++)
+ {
+ p.octave_i_ = (*pitch_arr_p)[i].octave_i_;
+ if (p == (*pitch_arr_p)[i])
+ return i;
+ }
}
- sub_arr_p->sort (Musical_pitch::compare);
+ return i;
+}
+
+static int
+trap_i (Musical_pitch tonic, Musical_pitch p)
+{
+ int i = p.notename_i_ - tonic.notename_i_
+ + (p.octave_i_ - tonic.octave_i_) * 7;
+ while (i < 0)
+ i += 7;
+ i++;
+ return i;
+}
+static Array<Musical_pitch>
+missing_triads_pitch_arr (Array<Musical_pitch>const* pitch_arr_p)
+{
Musical_pitch third (2);
Musical_pitch mthird (2, -1);
- Musical_pitch missing;
- missing = tonic;
- missing.transpose (third);
-
- Musical_pitch p;
- p = tonic;
- p.transpose (third);
- p.transpose (mthird);
-
- /*
- must have minimum at 5 (3 is added automatically as missing)
- */
- if (!add_arr_p->size ())
- add_arr_p->push (p);
- else if ((add_arr_p->top () < p) && (add_arr_p->top ().notename_i_ != p.notename_i_))
- add_arr_p->push (p);
- add_arr_p->sort (Musical_pitch::compare);
Array<Musical_pitch> triads;
triads.push (third); // c e
triads.push (mthird); // a c
triads.push (mthird); // b d
+ Musical_pitch tonic = (*pitch_arr_p)[0];
+ Musical_pitch last = tonic;
+ Array<Musical_pitch> missing_arr;
+
+ for (int i = 0; i < pitch_arr_p->size ();)
+ {
+ Musical_pitch p = (*pitch_arr_p)[i];
+ int trap = trap_i (tonic, p);
+ if (last.notename_i_ == p.notename_i_)
+ last.transpose (triads[(last.notename_i_ - tonic.notename_i_ + 7) % 7]);
+ if (trap > trap_i (tonic, last))
+ {
+ while (trap > trap_i (tonic, last))
+ {
+ if ((last.notename_i_ - tonic.notename_i_ + 7) % 7 == 6)
+ {
+ Musical_pitch special_seven = last;
+ Musical_pitch lower (0, -1);
+ special_seven.transpose (lower);
+ missing_arr.push (special_seven);
+ }
+ else
+ {
+ missing_arr.push (last);
+ }
+ last.transpose (triads[(last.notename_i_ - tonic.notename_i_ + 7) % 7]);
+ }
+ }
+ else
+ {
+ i++;
+ }
+ }
+ return missing_arr;
+}
+
+
+/*
+ construct from parser output
+*/
+Chord::Chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p)
+{
+ rebuild_transpose (tonic, add_arr_p);
+ rebuild_transpose (tonic, sub_arr_p);
+
+ Musical_pitch fifth = tonic;
+ fifth.transpose (Musical_pitch (2));
+ fifth.transpose (Musical_pitch (2, -1));
+
+ /*
+ default chord includes upto 5: <1, 3, 5>
+ */
+ add_arr_p->insert (tonic, 0);
+ int highest_trap = trap_i (tonic, add_arr_p->top ());
+ if (highest_trap < 5)
+ add_arr_p->push (fifth);
+
/*
- if first addition is 4, assume sus4 and don't add third implicitely
+ find missing triads
*/
- Musical_pitch sus (3);
- sus.transpose (tonic);
- if (add_arr_p->size ())
- if ((*add_arr_p)[0] == sus)
- missing.transpose (mthird);
+ Array<Musical_pitch> missing_arr = missing_triads_pitch_arr (add_arr_p);
/*
- add missing triads
+ if additions include 4, assume sus4 and don't add third implicitely
*/
- for (int i = 0; i < add_arr_p->size ();)
+ Musical_pitch third = tonic;
+ third.transpose (Musical_pitch (2));
+ Musical_pitch sus = tonic;
+ sus.transpose (Musical_pitch (3));
+ if (::find_pitch_i (add_arr_p, sus) != -1)
{
- Musical_pitch p = (*add_arr_p)[i];
- if (p > missing)
- while (p > missing)
- {
- if (p.notename_i_ != missing.notename_i_)
- {
- if ((missing.notename_i_ - tonic.notename_i_ + 7) % 7 == 6)
- {
- Musical_pitch special_seven = missing;
- Musical_pitch lower (0, -1);
- special_seven.transpose (lower);
- add_arr_p->insert (special_seven, i++);
- }
- else
- add_arr_p->insert (missing, i++);
- }
- missing.transpose (triads[(missing.notename_i_ - tonic.notename_i_ + 7) % 7]);
- }
- else if (p.notename_i_ == missing.notename_i_)
- missing.transpose (triads[(missing.notename_i_ - tonic.notename_i_ + 7) % 7]);
- else
- i++;
+ int i = ::find_pitch_i (&missing_arr, third);
+ if (i != -1)
+ missing_arr.get (i);
}
-
+
/*
- add tonic
+ complete the list of triads to be added
*/
- if (!add_arr_p->size () || ((*add_arr_p)[0] != tonic))
- add_arr_p->insert (tonic, 0);
+ add_arr_p->concat (missing_arr);
+ add_arr_p->sort (Musical_pitch::compare);
/*
add all that aren't subtracted
pitch_arr_.push (p);
}
+ pitch_arr_.sort (Musical_pitch::compare);
+
for (int i = 0; i < sub_arr_p->size (); i++)
warning (_f ("invalid subtraction: not part of chord: %s",
(*sub_arr_p)[i].str ()));
{
int i = 0;
for (; i < pitch_arr_.size (); i++)
- if ((pitch_arr_[i].notename_i_ == inversion_p->notename_i_)
- && (pitch_arr_[i].accidental_i_ == inversion_p->accidental_i_))
- break;
+ {
+ if ((pitch_arr_[i].notename_i_ == inversion_p->notename_i_)
+ && (pitch_arr_[i].accidental_i_ == inversion_p->accidental_i_))
+ break;
+ }
if (i == pitch_arr_.size ())
- warning (_f ("invalid inversion pitch: not part of chord: %s",
- inversion_p->str ()));
+ {
+ warning (_f ("invalid inversion pitch: not part of chord: %s",
+ inversion_p->str ()));
+ }
else
- {
- /*
- urg
- should be run-time switchable "chordInversionPreserve", howto?
-
- there are two ways commonly used to rearrange a chord with
- an inversion:
-
- 1. rebuild pitch list, taking inversion as base
- */
-#if 0
- rebuild_from_base (i);
+ {
+#if INVERSION_ADDED_AS_BASE
+ pitch_arr_.insert (pitch_arr_[i], 0);
+ rebuild_with_bass (0);
#else
- /*
- or
- 2. insert inversion as lowest (at first position)
- */
rebuild_with_bass (i);
#endif
+
}
delete inversion_p;
}
}
+void
+Chord::find_additions_and_subtractions(Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p)
+{
+ Musical_pitch tonic = pitch_arr_[0];
+ /*
+ all the triads that should be there
+ */
+ Array<Musical_pitch> all_arr;
+ all_arr.push (tonic);
+ all_arr.push (pitch_arr_.top ());
+ all_arr.concat (missing_triads_pitch_arr (&all_arr));
+ all_arr.sort (Musical_pitch::compare);
+
+ int i = 0;
+ int j = 0;
+ while ((i < all_arr.size ()) || (j < pitch_arr_.size ()))
+ {
+ i = i <? all_arr.size () - 1;
+ j = j <? pitch_arr_.size () - 1;
+ Musical_pitch a = all_arr[i];
+ Musical_pitch p = pitch_arr_[j];
+ if (a == p)
+ {
+ i++;
+ j++;
+ }
+ else if ((p < a) || (p.notename_i_ == a.notename_i_))
+ {
+ add_arr_p->push (p);
+ j++;
+ }
+ else
+ {
+ sub_arr_p->push (a);
+ i++;
+ }
+ }
+
+ /*
+ add highest addition, because it names chord
+ */
+ if (trap_i (tonic, pitch_arr_.top () > 5))
+ add_arr_p->push (pitch_arr_.top ());
+}
+
String
Chord::banter_str (Musical_pitch* inversion) const
{
Musical_pitch tonic = pitch_arr_[0];
+ //urg, should do translation in scheme.
+ char const *acc[] = {"\\textflat\\textflat ", "\\textflat ", "", "\\textsharp " , "\\textsharp\\textsharp "};
+ String tonic_str = tonic.str ();
+ tonic_str = tonic_str.left_str (1).upper_str ()
+ + acc[tonic.accidental_i_ + 2];
+
+ Array<Musical_pitch> add_arr;
+ Array<Musical_pitch> sub_arr;
+ find_additions_and_subtractions (&add_arr, &sub_arr);
+
Array<Musical_pitch> scale;
scale.push (Musical_pitch (0)); // c
scale.push (Musical_pitch (1)); // d
scale.push (Musical_pitch (3)); // f
scale.push (Musical_pitch (4)); // g
scale.push (Musical_pitch (5)); // a
+ scale.push (Musical_pitch (6)); // b
// 7 always means 7-...
- scale.push (Musical_pitch (6, -1)); // b
-
+ // scale.push (Musical_pitch (6, -1)); // b
- for (int i = 0; i < scale.size (); i++)
- scale[i].transpose (tonic);
-
- //urg, should do translation in scheme.
- char const *acc[] = {"\\textflat\\textflat ", "\\textflat ", "", "\\textsharp " , "\\textsharp\\textsharp "};
- String tonic_str = tonic.str ();
- tonic_str = tonic_str.left_str (1).upper_str ()
- + acc[tonic.accidental_i_ + 2];
-
- String add_str;
- String sub_str;
+ rebuild_transpose (tonic, &scale);
+
+ bool has3m_b = false;
+ bool has4_b = false;
+ String str;
String sep_str;
- String sub_sep_str;
- int last_trap = 1;
- for (int i=1; i < pitch_arr_.size (); i++)
+ for (int i = 0; i < add_arr.size (); i++)
{
- Musical_pitch p = pitch_arr_[i];
- int trap = p.notename_i_ - tonic.notename_i_
- + (p.octave_i_ - tonic.octave_i_) * 7;
- while (trap < 0)
- trap += 7;
- trap++;
- while (trap - last_trap > 2)
- {
- last_trap += 2;
- sub_str += sub_sep_str + "no" + to_str (last_trap);
- sub_sep_str = "/";
- }
- last_trap = trap;
+ Musical_pitch p = add_arr[i];
+ int trap = trap_i (tonic, p);
+ if (trap == 4)
+ has4_b = true;
int accidental = p.accidental_i_ - scale[(trap - 1) % 7].accidental_i_;
if ((trap == 3) && (accidental == -1))
- tonic_str += "m"; // hmm
- else if (accidental || (!(trap % 2) || ((i + 1 == pitch_arr_.size ()) && (trap > 5))))
+ {
+ tonic_str += "m";
+ has3m_b = true;
+ }
+ else if (accidental
+ || (!(trap % 2) || ((i + 1 == add_arr.size ()) && (trap > 5))))
{
- add_str += sep_str;
+ str += sep_str;
if ((trap == 7) && (accidental == 1))
- add_str += "maj7";
+ str += "maj7";
else
{
- add_str += to_str (trap);
+ str += to_str (trap);
if (accidental)
- add_str += accidental < 0 ? "-" : "+";
- // catch "C4/no3"; remove "no3"
- if (trap == 4)
- {
- int i = sub_str.index_i ("no3");
- if (i != -1)
- sub_str = sub_str.nomid_str (i, 3);
- if (!sub_str.length_i ())
- sub_sep_str = "";
- }
+ str += accidental < 0 ? "-" : "+";
}
sep_str = "/";
}
}
+ for (int i = 0; i < sub_arr.size (); i++)
+ {
+ Musical_pitch p = sub_arr[i];
+ int trap = trap_i (tonic, p);
+ /*
+ if chord has 3-, assume minor and don't display 'no3'
+ if additions include 4, assume sus4 and don't display 'no3'
+ */
+ if (!((trap == 3) && (has3m_b || has4_b)))
+ {
+ str += sep_str + "no" + to_str (trap);
+ sep_str = "/";
+ }
+ }
+
String inversion_str;
if (inversion)
{
inversion_str = inversion->str ();
inversion_str = "/" + inversion_str.left_str (1).upper_str ()
- + acc[tonic.accidental_i_ + 2];
+ + acc[inversion->accidental_i_ + 2];
}
- if (sub_str.length_i ())
- sub_str = sep_str + sub_str;
- String str = tonic_str + "$^{" + add_str + sub_str + "}$" + inversion_str;
- return str;
+ return tonic_str + "$^{" + str + "}$" + inversion_str;
+}
+
+int
+Chord::find_notename_i (Musical_pitch p) const
+{
+ return ::find_notename_i (&pitch_arr_, p);
+}
+
+int
+Chord::find_pitch_i (Musical_pitch p) const
+{
+ return ::find_pitch_i (&pitch_arr_, p);
}
int
void
Chord::rebuild_from_base (int base_i)
{
+ assert (base_i >= 0);
Musical_pitch last (0, 0, -5);
Array<Musical_pitch> new_arr;
for (int i = 0; i < pitch_arr_.size (); i++)
void
Chord::rebuild_insert_inversion (int tonic_i)
{
+ assert (tonic_i > 0);
+#if INVERSION_ADDED_AS_BASE
+ // inversion was added; don't insert
+ Musical_pitch inversion = pitch_arr_.get (0);
+ (void)inversion;
+#else
Musical_pitch inversion = pitch_arr_.get (0);
rebuild_from_base (tonic_i - 1);
if (pitch_arr_.size ())
pitch_arr_.insert (inversion, i);
break;
}
+#endif
}
void
Chord::rebuild_with_bass (int bass_i)
{
+ assert (bass_i >= 0);
Musical_pitch inversion = pitch_arr_.get (bass_i);
// is lowering fine, or should others be raised?
if (pitch_arr_.size ())
#include "molecule.hh"
#include "paper-def.hh"
#include "lookup.hh"
-#include "clef-engraver.hh"
#include "g-text-item.hh"
#include "p-score.hh"
String t = symbol_;
if (change_b_)
t += "_change";
- // Atom s = lookup_l ()-> text ("roman", to_str (break_status_dir ()));
-
- Atom s = lookup_l ()->clef (t);
- Molecule*output = new Molecule (Atom (s));
+
+ Molecule*output = new Molecule (lookup_l ()->clef (t));
return output;
}
(shaddup)
*/
Offset o (x_off[j] * wid_f, y_off[j] * inter_f);
- ((Score_element*)col_l_a[j])->translate (o);
+ col_l_a[j]->translate (o);
+ // ((Score_element*)col_l_a[j])->translate (o);
}
}
}
Partial_measure_req::Partial_measure_req (Moment m)
{
- duration_ =m;
+ length_mom_ =m;
}
bool
{
Partial_measure_req *p = dynamic_cast <Partial_measure_req *> (r);
- return p&& p->duration_ == duration_;
+ return p&& p->length_mom_ == length_mom_;
}
void
Partial_measure_req::do_print() const
{
- DOUT << duration_;
+ DOUT << length_mom_;
}
{
Tempo_req *t = dynamic_cast <Tempo_req *> (r);
- return t&& t->dur_.length()== dur_.length () && metronome_i_ == t->metronome_i_;
+ return t&& t->dur_.length_mom ()== dur_.length_mom () && metronome_i_ == t->metronome_i_;
}
#include "debug.hh"
#include "score-column.hh"
-Crescendo::Crescendo()
+Crescendo::Crescendo ()
{
grow_dir_ =0;
dir_ = DOWN;
}
Interval
-Crescendo::symbol_height() const
+Crescendo::symbol_height () const
{
- return get_symbol().dim_[Y_AXIS];
+ return get_symbol ().dim_[Y_AXIS];
}
static Real absdyn_dim = 10 PT; // ugh
-Atom
-Crescendo::get_symbol() const
+Molecule
+Crescendo::get_symbol () const
{
- Real w_dim = extent(X_AXIS).length ();
+ Real w_dim = extent (X_AXIS).length ();
if (dyn_b_drul_[LEFT])
{
w_dim -= absdyn_dim;
if (w_dim < 0)
{
- warning (_ ("crescendo") + " " + _("too small"));
+ warning (_ ("crescendo") + " " + _ ("too small"));
w_dim = 0;
}
Drul_array<bool> broken;
Direction d = LEFT;
do {
- Score_column* s = (Score_column* )spanned_drul_[d] ; // UGH
- broken[d] = (!s->musical_b());
- } while (flip(&d) != LEFT);
+ Score_column* s = dynamic_cast<Score_column*>(spanned_drul_[d]); // UGH
+ broken[d] = (!s->musical_b ());
+ } while (flip (&d) != LEFT);
- bool continued = broken[(Direction)-grow_dir_];
- return Atom (lookup_l ()->hairpin (w_dim, grow_dir_ < 0, continued));
+ bool continued = broken[Direction (-grow_dir_)];
+ return Molecule (lookup_l ()->hairpin (w_dim, grow_dir_ < 0, continued));
}
Molecule*
-Crescendo::do_brew_molecule_p() const
+Crescendo::do_brew_molecule_p () const
{
Molecule* m_p =0;
Real x_off_dim=0.0;
x_off_dim += absdyn_dim;
m_p = new Molecule;
- Atom s (get_symbol());
- m_p->add_atom (s);
+ Molecule s (get_symbol ());
+ m_p->add_molecule (s);
m_p->translate (Offset (x_off_dim, coordinate_offset_f_));
return m_p;
}
{
init();
empty_b_ = d.empty_b_;
+ offset_ = d.offset_; //let's hope others will copy the refpoint appropriately.
}
Dimension_cache::Dimension_cache ()
Dots::do_brew_molecule_p () const
{
Molecule *out = new Molecule;
- Atom fill = lookup_l ()->fill (Box (Interval (0,0),
+ Molecule fill = lookup_l ()->fill (Box (Interval (0,0),
Interval (0,0)));
- out->add_atom (fill);
+ out->add_molecule (fill);
- Atom d = lookup_l ()->dots ();
+ Molecule d = lookup_l ()->dots ();
Real dw = d.dim_[X_AXIS].length ();
d.translate_axis (-dw, X_AXIS);
for (int i=no_dots_i_; i--; )
{
d.translate_axis (2*dw,X_AXIS);
- out->add_atom (d);
+ out->add_molecule (d);
}
Real inter_f = paper ()->internote_f ();
out->translate_axis (inter_f * position_i_, Y_AXIS);
continue;
}
- String loud = absd->loudness_str ();
+ String loud = absd->loudness_str_;
text_p_ = new G_text_item;
- text_p_->text_str_ = "dyn" + loud; // ugh
+ text_p_->text_str_ = loud; // ugh
Scalar prop = get_property ("dynamicStyle", 0);
text_p_->style_str_ = prop.length_i () ? prop : "dynamic";
Link_array<Translator_group> groups = group_l_arr ();
for (int i=0; i < groups.size(); i++)
{
- Engraver * eng = dynamic_cast<Engraver*> (groups[i]);
- if (eng)
+ Engraver_group_engraver * group = dynamic_cast<Engraver_group_engraver*> (groups[i]);
+ if (group)
{
- Engraver_group_engraver * group =
- (Engraver_group_engraver*) eng;
group->do_announces();
}
}
#include "engraver.hh"
#include "engraver-group.hh"
#include "debug.hh"
+#include "paper-def.hh"
void
Engraver::fill_staff_info (Staff_info&)
Paper_def*
Engraver::paper() const
{
- return (Paper_def*)output_def_l_;
+ return dynamic_cast<Paper_def*>(output_def_l_);
}
(c) 1998 Jan Nieuwenhuizen <janneke@gnu.org>
*/
-#include "atom.hh"
+
#include "box.hh"
#include "debug.hh"
#include "lookup.hh"
Real w = extent (X_AXIS).length ();
w += (dx_f_drul_[RIGHT] - dx_f_drul_[LEFT]);
-
- Atom a = lookup_l ()->extender (w);
-
+ Real h = paper ()->get_realvar (ly_symbol ("extender_height"));
+ Molecule a = lookup_l ()->filledbox ( Box (Interval (0,w), Interval (0,h)));
a.translate (Offset (dx_f_drul_[LEFT], dy_f_drul_[LEFT]));
- mol_p->add_atom (a);
+ mol_p->add_molecule (a);
return mol_p;
}
*/
#include "g-text-item.hh"
-#include "atom.hh"
+
#include "molecule.hh"
#include "paper-def.hh"
#include "lookup.hh"
Molecule*
G_text_item::do_brew_molecule_p () const
{
- Atom a= paper ()->lookup_l(0)->text (style_str_,text_str_);
+ Molecule a= paper ()->lookup_l(0)->text (style_str_,text_str_);
return new Molecule (a);
}
(c) 1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-
+#include "molecule.hh"
#include "general-script-def.hh"
#include "debug.hh"
-#include "atom.hh"
+
Direction
General_script_def::staff_dir() const
{
}
-Atom
-General_script_def::get_atom (Paper_def*, Direction) const
+Molecule
+General_script_def::get_molecule (Paper_def*, Direction) const
{
- Atom s;
- return Atom (s);
+ Molecule s;
+ return Molecule (s);
}
-Interval
-General_script_def::width (Paper_def*) const
-{
- Interval t;
- return t;
-}
--- /dev/null
+/*
+ global-ctor.cc -- implement
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+#include "global-ctor.hh"
+#include "array.hh"
+
+static Array<Global_ctor> *ctor_global_static_arr_p_;
+
+void
+add_constructor (Global_ctor c)
+{
+ if (!ctor_global_static_arr_p_)
+ ctor_global_static_arr_p_ = new Array<Global_ctor>;
+ ctor_global_static_arr_p_->push (c);
+}
+
+void
+call_constructors ()
+{
+ for (int i=0; i < ctor_global_static_arr_p_->size (); i++)
+ (ctor_global_static_arr_p_->elem (i)) ();
+}
}
Moment
-Global_translator::now_moment () const
+Global_translator::now_mom () const
{
return now_mom_;
}
Interval
Graphical_element::extent (Axis a) const
{
- Dimension_cache const * d = //(Dimension_cache*)
- &dim_cache_[a];
+ Dimension_cache const * d = &dim_cache_[a];
if (d->empty_b ())
return Interval ();
}
bool
-Note_heads_engraver::do_try_music (Music *req_l)
+Note_heads_engraver::do_try_music (Music *m)
{
- if (Note_req * n =dynamic_cast <Note_req *> (req_l))
+ if (Note_req * n =dynamic_cast <Note_req *> (m))
{
note_req_l_arr_.push (n);
return true;
}
+ if (Tonic_req* t = dynamic_cast<Tonic_req*> (m))
+ {
+ return true;
+ }
return false;
}
#include "string.hh"
#include "box.hh"
#include "lily-proto.hh"
+#include "lily-guile.hh"
+#if 0
/// a symbol which can be translated, and freely copied
class Atom {
+ static long smob_tag_;
+
+ static SCM smob_mark (SCM);
+ static scm_sizet smob_free (SCM);
+ static int smob_display (SCM, SCM, scm_print_state*);
+ Atom (SCM s);
+ SCM make_smob () const;
+public:
Offset off_;
+ static SCM make_atom (SCM outputfunc);
+ SCM copy_self () const;
+ static Atom *atom_l (SCM);
+
+ /// Is #obj# a Foo?
+ static bool Atom_b(SCM obj);
+ static void init_smob ();
+ SCM func_;
+ SCM font_;
+};
+
+#else
+
+class Atom {
public:
- Protected_scm lambda_;
- Score_element * origin_l_;
-
- // urg, only used as a temp buffer
- String str_;
- String font_;
- Box dim_;
-
- Offset offset () const;
- String str() const; // for printing.
- Atom (String, Box);
- Atom ();
- void translate (Offset o);
- void translate_axis (Real r,Axis a);
- /// how big is #this#?
- Box extent() const;
- Interval extent (Axis)const;
- void print() const;
- bool check_infinity_b () const;
- bool empty() const;
+ Atom (SCM s);
+ Offset off_;
+ /*
+ SCM expression that (when evaluated) gives a TeX string
+representing a musical notation symbol. */
+ Protected_scm func_;
+ Protected_scm font_;
};
+
+#endif
+
#endif
class Bar:public Item {
public:
String type_str_;
+ bool at_line_start_b_;
VIRTUAL_COPY_CONS(Score_element);
--- /dev/null
+/*
+ base-span-bar-engraver.hh -- declare Span_bar_engraver
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+*/
+
+
+#ifndef SPAN_BAR_GRAV_HH
+#define SPAN_BAR_GRAV_HH
+
+#include "engraver.hh"
+
+/**
+
+ Make bars that span multiple "staffs". Catch bars, and span a
+ Span_bar over them if we find more than 2 bars
+
+ */
+class Base_span_bar_engraver : public Engraver
+{
+ Span_bar * spanbar_p_;
+ Array<Bar*> bar_l_arr_;
+ Vertical_align_spanner * valign_l_;
+public:
+ VIRTUAL_COPY_CONS(Translator);
+
+
+ Base_span_bar_engraver();
+protected:
+ /**
+ Do we use break priorities? If true, use break_priority_i_ as
+ horizontal alignment priority, otherwise, hang the spanbar on the
+ acknowledged bar. */
+ bool use_priority_b_;
+ int break_priority_i_;
+
+ virtual void acknowledge_element (Score_element_info);
+ virtual void do_pre_move_processing();
+ virtual Span_bar* get_span_bar_p() const;
+};
+
+#endif // SPAN_BAR_GRAV_HH
Beam *finished_beam_p_;
Beam *beam_p_;
-
+ Beam_req * prev_start_req_;
Rhythmic_grouping*grouping_p_;
Rhythmic_grouping*finished_grouping_p_;
void translate (Offset o);
/// smallest box enclosing #b#
+ void set_empty ();
void unite (Box b);
Box();
Box (Interval ix, Interval iy);
class Change_iterator : public Music_iterator
{
- Change_translator *change_l ();
void error (String);
protected:
#include "engraver.hh"
#include "array.hh"
#include "musical-pitch.hh"
-
#include "lily-proto.hh"
-Array<Musical_pitch> rebuild_from_base_pitch_arr (Array<Musical_pitch> pitch_arr, int base_i);
-Array<Musical_pitch> rebuild_insert_inversion_pitch_arr (Array<Musical_pitch> pitch_arr, int tonic_i);
-Array<Musical_pitch> rebuild_with_bass_pitch_arr (Array<Musical_pitch> pitch_arr, int bass_i);
-
-
class Chord_name_engraver : public Engraver
{
+public:
+ Chord_name_engraver ();
+ VIRTUAL_COPY_CONS (Translator);
+
protected:
virtual void do_pre_move_processing ();
virtual void acknowledge_element (Score_element_info i);
virtual void do_process_requests ();
virtual bool do_try_music (Music* m);
-public:
- Chord_name_engraver ();
- VIRTUAL_COPY_CONS (Translator);
-
private:
Array<Musical_pitch> pitch_arr_;
Link_array<Item> text_p_arr_;
-
- String banter_str (Array<Musical_pitch> pitch_arr, Musical_pitch* inversion) const;
- int find_tonic_i () const;
Array<Musical_pitch> rebuild_pitch_arr (int tonic_i) const;
+ Tonic_req* tonic_req_;
};
#endif // CHORD_NAME_ENGRAVER_HH
String banter_str (Musical_pitch* inversion) const;
int find_tonic_i () const;
+ int find_pitch_i (Musical_pitch p) const;
+ int find_notename_i (Musical_pitch p) const;
+ void find_additions_and_subtractions(Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p);
Array<Musical_pitch> pitch_arr_;
- int tonic_i_;
};
#endif // CHORD_HH
#ifndef COLHPOS_HH
#define COLHPOS_HH
-#include "array.hh"
+#include "parray.hh"
#include "lily-proto.hh"
-typedef Array<Paper_column*> Line_of_cols;
+typedef Link_array<Paper_column> Line_of_cols;
struct Column_x_positions {
Line_spacer * spacer_l_;
class Partial_measure_req : public Timing_req {
public:
- Moment duration_;
+ Moment length_mom_;
Partial_measure_req (Moment);
REQUESTMETHODS(Partial_measure_req);
--- /dev/null
+/*
+ cons.cc -- implement
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#include "cons.hh"
--- /dev/null
+/*
+ cons.hh -- declare
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#ifndef CONS_HH
+#define CONS_HH
+
+template<class T>
+class Cons
+{
+public:
+ T * car_;
+ Cons * next_;
+ virtual ~Cons ();
+ Cons () {
+ car_=0;
+ next_ =0;
+ }
+ Cons (T*t, Cons<T>*c)
+ {
+ car_ = t;
+ next_ = c;
+ }
+};
+
+template<class T>
+class Killing_cons : public Cons<T>
+{
+public:
+ Killing_cons (T *t, Cons<T> *p)
+ : Cons<T>( t,p)
+ {
+ }
+ virtual ~Killing_cons ();
+};
+
+#endif /* CONS_HH */
+
private:
- Atom get_symbol() const;
+ Molecule get_symbol() const;
};
#endif // CRESCENDO_HH
virtual Direction rel_stem_dir() const;
virtual int priority_i() const;
virtual bool inside_b() const;
- virtual Atom get_atom (Paper_def* p, Direction dir_) const;
+ virtual Molecule get_molecule (Paper_def* p, Direction dir_) const;
bool equal_b (General_script_def const&) const;
virtual ~General_script_def() {}
-
- virtual Interval width (Paper_def *) const;
protected:
virtual bool do_equal_b (General_script_def const *) const;
virtual void do_print() const;
--- /dev/null
+/*
+ global-ctor.hh -- declare Global construction stuff.
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#ifndef GLOBAL_CTOR_HH
+#define GLOBAL_CTOR_HH
+
+
+#define ADD_GLOBAL_CTOR_WITHNAME(y,x)\
+class Global_ctor_ ## y \
+{\
+public: \
+ Global_ctor_ ## y () { \
+ add_constructor (x); \
+ } \
+} _ ## y ## _ctor_init; \
+
+
+#define ADD_GLOBAL_CTOR(x) ADD_GLOBAL_CTOR_WITHNAME(x,x);
+
+
+typedef void (* Global_ctor ) ();
+void add_constructor (Global_ctor ctor);
+void call_constructors ();
+
+#endif /* GLOBAL_CTOR_HH */
+
protected:
- virtual Moment now_moment () const;
+ virtual Moment now_mom () const;
virtual Global_translator *global_l() { return this; }
};
#include <FlexLexer.h>
#include "string.hh"
-#include "array.hh"
+#include "parray.hh"
#include "fproto.hh"
#include "proto.hh"
protected:
bool close_input ();
- Array<Source_file*> include_stack_;
+ Link_array<Source_file> include_stack_;
Array<int> char_count_stack_;
public:
--- /dev/null
+/*
+ killing-cons.tcc -- declare Killing_cons
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#ifndef KILLING_CONS_TCC
+#define KILLING_CONS_TCC
+
+template<class T>
+Cons<T>::~Cons ()
+{
+}
+
+template<class T>
+Killing_cons<T>::~Killing_cons ()
+{
+ delete car_;
+ delete next_;
+}
+
+
+#endif /* KILLING_CONS_TCC */
+
struct Time_signature_change_req;
struct Time_signature_engraver;
struct Time_signature_performer;
+struct Tonic_req;
struct Translator;
struct Translator_group;
struct Timing_req;
class Line_of_score : public Spanner , public Super_element
{
public:
- Link_array<Paper_column> cols;
+ Link_array<Paper_column> cols_;
bool error_mark_b_;
#ifndef LOOKUP_HH
#define LOOKUP_HH
-#include "atom.hh"
#include "molecule.hh"
#include "fproto.hh"
-#include "scalar.hh"
#include "direction.hh"
#include "box.hh"
- Atom special_ball (int, String) const;
- Atom simple_bar (String s, Real w) const;
+ Molecule special_ball (int, String) const;
+ Molecule simple_bar (String s, Real w) const;
Molecule accidental (int, bool cautionary) const;
- Atom afm_find (String, bool warn=true) const;
- Atom ball (int) const;
+ Molecule afm_find (String, bool warn=true) const;
+ Molecule ball (int) const;
Molecule bar (String, Real height) const;
- Atom beam (Real, Real, Real) const;
- Atom clef (String) const;
- Atom dashed_slur (Array<Offset> controls, Real thick, Real dash) const;
- Atom dots () const;
- Atom extender (Real) const;
- Atom fill (Box b) const;
- Atom flag (int, Direction) const;
- Atom hairpin (Real width, bool decresc, bool continued) const;
- Atom plet (Real dy, Real dx, Direction dir) const;
- Atom rest (int, bool outside) const;
- Atom rule_symbol (Real height, Real width) const;
- Atom script (String idx) const;
- Atom stem (Real y1_pos, Real y2_pos) const;
- Atom slur (Array<Offset> controls) const;
- Atom streepje (int type) const;
- Atom text (String style, String text) const;
- Atom vbrace (Real &dy) const;
- Atom vbracket (Real &dy) const;
- Atom volta (Real w, bool last_b) const;
- Atom special_time_signature (String, Array<int>) const;
- Atom time_signature (Array<int>) const;
+ Molecule beam (Real, Real, Real) const;
+ Molecule clef (String) const;
+ Molecule dashed_slur (Array<Offset> controls, Real thick, Real dash) const;
+ Molecule dots () const;
+ Molecule ledger_line (Interval) const;
+ Molecule fill (Box b) const;
+ Molecule filledbox (Box b) const;
+ Molecule flag (int, Direction) const;
+ Molecule hairpin (Real width, bool decresc, bool continued) const;
+ Molecule plet (Real dy, Real dx, Direction dir) const;
+ Molecule rest (int, bool outside) const;
+ Molecule rule_symbol (Real height, Real width) const;
+ Molecule script (String idx) const;
+ Molecule stem (Real y1_pos, Real y2_pos) const;
+ Molecule slur (Array<Offset> controls) const;
+ Molecule streepje (int type) const;
+ Molecule text (String style, String text) const;
+ Molecule staff_brace (Real dy) const;
+ Molecule staff_bracket (Real dy) const;
+ Molecule volta (Real w, bool last_b) const;
+ Molecule special_time_signature (String, int,int) const;
+ Molecule time_signature (int n,int d) const;
Paper_def * paper_l_;
virtual void do_process_requests();
private:
- Array<Lyric_req*> lreq_arr_;
+ Link_array<Lyric_req> lreq_arr_;
};
#endif // LYRIC_PERFOMER_HH
Midi_def();
~Midi_def();
- Real duration_to_seconds_f (Moment);
+ Real length_mom_to_seconds_f (Moment);
int get_tempo_i (Moment moment);
void print() const;
void set_tempo (Moment moment, int count_per_minute_i);
Midi_note (Audio_item* audio_item_l);
- Moment duration () const;
+ Moment length_mom () const;
int pitch_i () const;
virtual String str () const;
#ifndef STANDALONE
#include "lily-proto.hh"
-Interval itemlist_width (const Array<Item*> &its);
+Interval itemlist_width (const Link_array<Item> &its);
#endif
void set_frobnify (void*, size_t);
#include "box.hh"
#include "axes.hh"
#include "direction.hh"
+#include "protected-scm.hh"
+#include "cons.hh"
/** a group of individually translated symbols. You can add molecules
to the top, to the right, etc. */
-struct Molecule {
- Pointer_list<Atom*> atoms_; // change to List<Atom>?
+class Molecule {
+ // Protected_scm atom_list_; // change to List<Atom>?
+ Killing_cons<Atom> *atom_list_;
+ friend class Paper_outputter;
+public:
+ Box dim_;
-
- Molecule() { }
- Molecule (Atom const &a);
+ Molecule();
+ ~Molecule();
void add_at_edge (Axis a, Direction d, const Molecule &m, Real padding);
void add_molecule (Molecule const &m);
void translate (Offset);
+ void do_center (Axis);
void translate_axis (Real,Axis);
- void add_atom (Atom const & a) ;
+
+ void add_atom (Atom const *a);
/// how big is #this#?
Box extent() const;
Interval extent (Axis) const;
Molecule (const Molecule&s);
void print() const;
-private:
- void operator=(const Molecule&);
+ void operator=(const Molecule&);
};
#endif
Simultaneous_music(Music_list *);
virtual Musical_pitch to_relative_octave (Musical_pitch);
- virtual Moment duration () const;
+ virtual Moment length_mom () const;
};
virtual Musical_pitch to_relative_octave (Musical_pitch);
Sequential_music(Music_list*);
- virtual Moment duration () const;
+ virtual Moment length_mom () const;
};
#endif // Music_sequence_HH
virtual bool ok () const;
protected:
- Music_wrapper *music_wrapper_l () const;
virtual void do_print () const;
virtual void do_process_and_next (Moment) ;
VIRTUAL_COPY_CONS(Music);
Music_wrapper (Music_wrapper const&);
- virtual Moment duration () const;
+ virtual Moment length_mom () const;
virtual ~Music_wrapper ();
virtual Musical_pitch to_relative_octave (Musical_pitch);
virtual Musical_pitch to_relative_octave (Musical_pitch);
/// The duration of this piece of music
- virtual Moment duration () const;
+ virtual Moment length_mom () const;
virtual ~Music(){}
void print() const;
bool do_equal_b (Request*) const;
void compress (Moment);
- virtual Moment duration() const;
+ virtual Moment length_mom () const;
static int compare (Rhythmic_req const&,Rhythmic_req const&);
REQUESTMETHODS(Rhythmic_req);
};
REQUESTMETHODS(Melodic_req);
};
+/// specify tonic of a chord
+struct Tonic_req : public Melodic_req
+{
+ Tonic_req ();
+ REQUESTMETHODS(Tonic_req);
+};
+
/// Put a note of specified type, height, and with accidental on the staff.
class Note_req : public Rhythmic_req, virtual public Melodic_req {
public:
class Dynamic_req : public virtual Musical_req {
public:
- /**
- for absolute dynamics
-
- This sux. We'd want increasing numbers for FFF till PPP, but not
- for FP, SF, SFZ (FP is *not* louder than FFF)
- */
- enum Loudness {
- FFFFFF, FFFFF, FFFF, FFF, FF, F, MF, MP, P, PP, PPP, PPPP, PPPPP, PPPPPP, FP, SF, SFF, SFZ, SP, SPP, RFZ };
- static String loudness_static_str (Loudness);
REQUESTMETHODS(Dynamic_req);
};
class Absolute_dynamic_req : public Dynamic_req {
public:
- Loudness loudness_;
+ String loudness_str_;
virtual bool do_equal_b (Request*) const;
String loudness_str () const;
Absolute_dynamic_req();
Notename_table *chordmodifier_tab_p_;
Notename_table *note_tab_p_;
- Array<Scope*> scope_l_arr_;
+ Link_array<Scope> scope_l_arr_;
Keyword_table * keytable_p_;
int errorlevel_i_;
#define MY_LILY_PARSER_HH
#include "lily-proto.hh"
#include "string.hh"
-#include "array.hh"
+#include "parray.hh"
#include "lily-proto.hh"
#include "lily-proto.hh"
#include "duration.hh"
bool first_b_;
- Array<Request*> pre_reqs, post_reqs;
+ Link_array<Request> pre_reqs, post_reqs;
int fatal_error_i_;
Sources * source_l_;
int error_level_i_;
void do_yyparse();
void parser_error (String);
- Array<Request*>* get_parens_request (int t);
+ Link_array<Request>* get_parens_request (int t);
void set_debug();
void set_yydebug (bool);
/** convert a duration to an idealspacing
influence using the geometric_ and paratime_signatures.
*/
- Real duration_to_dist (Moment, Real) const;
+ Real length_mom_to_dist (Moment, Real) const;
Real geometric_spacing (Moment) const;
Real arithmetic_constant (Moment minimal_mom) const;
Real arithmetic_spacing (Moment mom,Real constant) const;
void stop_line ();
void switch_to_font (String fontname);
- Array<String> font_arr_;
- String current_font_;
Paper_stream* outstream_l_;
};
Protected_scm (Protected_scm const &);
~Protected_scm ();
Protected_scm &operator = (Protected_scm const &);
- operator SCM ();
+ operator SCM () const;
SCM to_SCM () const;
};
Array<Moment> stop_mom_arr_;
Array<Moment> alternative_start_mom_arr_;
Array<Moment> alternative_stop_mom_arr_;
+ Array<String> alternative_str_arr_;
};
#endif // REPEAT_ENGRAVER_HH
virtual bool ok () const;
protected:
- virtual Repeated_music* repeated_music_l () const;
-
virtual void do_print () const;
virtual void do_process_and_next (Moment);
-
private:
void start_next_element ();
virtual void do_print () const;
virtual void transpose (Musical_pitch p);
- virtual Moment duration () const;
+ virtual Moment length_mom () const;
virtual Musical_pitch to_relative_octave (Musical_pitch p);
VIRTUAL_COPY_CONS(Music);
};
class Request_chord_iterator : public Music_iterator {
Request_chord * elt_l () const;
/**
- cache elt_l ()->duration ().
+ cache elt_l ()->length_mom ().
*/
- Moment elt_duration_;
+ Moment elt_length_mom_;
bool last_b_;
public:
--- /dev/null
+/*
+ rhythmic-grouping.hh -- part of GNU LilyPond
+
+ (c) 1996--1998 Han-Wen Nienhuys
+*/
+
+#ifndef RHYTHMIC_GROUPING_HH
+#define RHYTHMIC_GROUPING_HH
+
+#include "minterval.hh"
+#include "parray.hh"
+
+/** data structure which represents rhythmic units this is a tree. It groupes notes according to rules
+
+ TODO Documentation. Unhairing
+ */
+struct Rhythmic_grouping {
+ Link_array<Rhythmic_grouping> children;
+ MInterval *interval_;
+
+
+ Array<MInterval> intervals();
+ MInterval interval() const;
+ Moment length_mom () const;
+ void intersect (MInterval);
+
+ void operator=(Rhythmic_grouping const&);
+ Rhythmic_grouping (Rhythmic_grouping const&);
+ Rhythmic_grouping (MInterval, int n=1);
+ Rhythmic_grouping();
+ Rhythmic_grouping (Link_array<Rhythmic_grouping>);
+ ~Rhythmic_grouping();
+
+ void add_child (Moment start, Moment len);
+ bool child_fit_b (Moment start);
+ void split (Rhythmic_grouping r);
+ void split (Array<MInterval>);
+ void split (int n);
+
+ void print() const;
+ void OK() const;
+
+ Array<int> generate_beams (Array<int>, int&);
+
+ /** multiply self to span #i#.
+ In implementation, this isn't really const, but conceptually it is.
+ */
+ void extend (MInterval i) const;
+ void translate (Moment);
+private:
+ void init();
+ void junk();
+ void copy (Rhythmic_grouping const&);
+};
+
+
+Rhythmic_grouping parse_grouping (Array<int> beat_i_arr, Array<Moment> elt_length_arr);
+
+
+#endif // RHYTHMIC_GROUPING_HH
#include "scalar.hh"
#include "lily-proto.hh"
-#include "array.hh"
+#include "parray.hh"
/**
Data container for broadcasts
struct Score_element_info {
Score_element * elem_l_;
Music *req_l_;
- Array<Engraver*> origin_grav_l_arr_;
+ Link_array<Engraver> origin_grav_l_arr_;
Score_element_info (Score_element*, Music*);
Score_element_info();
virtual Direction rel_stem_dir() const;
virtual int priority_i() const;
virtual bool inside_b() const;
- virtual Atom get_atom (Paper_def* p, Direction dir_) const;
+ virtual Molecule get_molecule (Paper_def* p, Direction dir_) const;
virtual bool do_equal_b (General_script_def const *) const;
class Script_engraver : public Engraver {
- Array<Script *> script_p_arr_;
- Array<Script_req *> script_req_l_arr_;
+ Link_array<Script> script_p_arr_;
+ Link_array<Script_req> script_req_l_arr_;
public:
VIRTUAL_COPY_CONS(Translator);
virtual void do_substitute_dependency (Score_element*,Score_element*);
virtual void do_print() const;
virtual Interval symbol_height() const;
- virtual Interval symbol_width () const;
virtual void do_pre_processing();
virtual Interval do_width() const;
VIRTUAL_COPY_CONS(Score_element);
#include "engraver.hh"
class Slur_engraver :public Engraver {
- Array<Slur_req*> requests_arr_;
- Array<Slur_req*> new_slur_req_l_arr_;
- Array<Slur *> slur_l_stack_;
- Array<Slur*> end_slur_l_arr_;
+ Link_array<Slur_req> requests_arr_;
+ Link_array<Slur_req> new_slur_req_l_arr_;
+ Link_array<Slur> slur_l_stack_;
+ Link_array<Slur> end_slur_l_arr_;
protected:
virtual bool do_try_music (Music*);
class Span_bar : public virtual Bar
{
- Link_array<Score_element> spanning_l_arr_;
-
+ Link_array<Score_element> spanning_l_arr_;
+ Interval get_spanned_interval () const;
public:
- Span_bar();
+ Real extra_x_off_;
+ bool no_width_b_;
+ Span_bar();
- VIRTUAL_COPY_CONS(Score_element);
- void add_bar (Bar*);
- void set_align (Align_element *);
+ VIRTUAL_COPY_CONS(Score_element);
+ void add_bar (Bar*);
+ void set_align (Align_element *);
protected:
- void evaluate_empty ();
- virtual Interval do_width() const;
- virtual void do_pre_processing();
- virtual void do_post_processing();
-
- virtual void do_substitute_dependency (Score_element*,Score_element*);
- virtual Molecule * do_brew_molecule_p() const;
- virtual Molecule get_bar_sym (Real dy) const;
+ void evaluate_empty ();
+ virtual Interval do_width() const;
+ virtual void do_pre_processing();
+ virtual void do_post_processing();
+ virtual Interval do_height () const;
+ virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual Molecule * do_brew_molecule_p() const;
};
#endif // SPAN_BAR_HH
#ifndef SPAN_SCORE_BAR_GRAV_HH
#define SPAN_SCORE_BAR_GRAV_HH
-#include "span-bar-engraver.hh"
+#include "base-span-bar-engraver.hh"
/**
*/
-class Span_score_bar_engraver : public Span_bar_engraver
+class Span_score_bar_engraver : public Base_span_bar_engraver
{
public:
VIRTUAL_COPY_CONS (Translator);
-
+ Span_score_bar_engraver ();
virtual Span_bar* get_span_bar_p () const;
};
protected:
virtual Interval symbol_height () const;
- virtual Interval symbol_width () const;
Interval symbol_extent () const;
virtual Real get_position_f () const;
virtual void do_substitute_dependency (Score_element *, Score_element*);
*/
Direction stem_xdir_;
-public:
Link_array<Note_head> head_l_arr_;
Link_array<Rest> rest_l_arr_;
+public:
/// how many abbrev beam don't reach stem?
int beam_gap_i_;
virtual void do_print() const;
virtual Direction staff_dir() const;
- virtual Atom get_atom (Paper_def* p, Direction dir_) const;
+ virtual Molecule get_molecule (Paper_def* p, Direction dir_) const;
virtual ~Text_def() {};
virtual bool do_equal_b (const General_script_def*) const;
Text_def();
virtual void print() const;
- virtual Interval width (Paper_def*) const;
-private:
- Real guess_width_f(Atom&) const;
};
#endif // TEXT_DEF_HH
*/
-#ifndef METERGRAV_HH
-#define METERGRAV_HH
+#ifndef TIME_SIG_ENGRAVER_HH
+#define TIME_SIG_ENGRAVER_HH
#include "engraver.hh"
#include "time-description.hh"
-#include "grouping.hh"
+#include "rhythmic-grouping.hh"
/**
generate time_signatures.
Time_signature_engraver();
};
-#endif // METERGRAV_HH
+#endif // TIME_SIG_ENGRAVER_HH
#include "translator.hh"
#include "time-description.hh"
-#include "grouping.hh"
+#include "rhythmic-grouping.hh"
#include "parray.hh"
class Timing_translator : public virtual Translator
#ifndef TRANSLATOR_HH
#define TRANSLATOR_HH
-
+#include "global-ctor.hh"
#include "string.hh"
#include "lily-proto.hh"
#include "virtual-methods.hh"
*/
Music_output_def *output_def_l () const;
Scalar get_property (String, Translator_group **) const;
- virtual Moment now_moment () const;
+ virtual Moment now_mom () const;
protected:
enum {
};
-template<class T>
-class Translator_adder
-{
-public:
- static Translator *ctor ()
- {
- T *t = new T;
- t->type_str_ = classname (t);
- return t;
- }
- Translator_adder () {
- add_constructor (ctor);
- }
-};
-
/**
A macro to automate administration of translators.
*/
-#define ADD_THIS_TRANSLATOR(c) \
- Translator_adder<c> _ ## c ## init;
+#define ADD_THIS_TRANSLATOR(T) \
+static void _ ## T ## _adder () {\
+ T *t = new T;\
+ t->type_str_ = classname (t);\
+ add_translator (t);\
+}\
+ADD_GLOBAL_CTOR(_ ## T ## _adder);
+
-typedef Translator *(*Translator_ctor) ();
extern Dictionary<Translator*> *global_translator_dict_p;
void add_translator (Translator*trans_p);
-void add_constructor (Translator_ctor ctor);
Translator*get_translator_l (String s);
Item::find_prebroken_piece (Line_of_score*l) const
{
if (line_l() == l)
- return (Item*)this;
+ return (Item*)(this);
else if (broken_to_drul_[LEFT] && broken_to_drul_[LEFT]->line_l() == l)
return broken_to_drul_[LEFT];
else if (broken_to_drul_[RIGHT] && broken_to_drul_[RIGHT]->line_l() == l)
Item::find_prebroken_piece (Direction breakstatus) const
{
if (!breakstatus)
- return (Item *) this; // ugh
+ return (Item *)(this); // ugh
else
- return (Item*) broken_to_drul_[breakstatus];
+ return dynamic_cast<Item*>( broken_to_drul_[breakstatus]);
}
void
cerr << _ ("missing end quote") << endl;
exit (1);
}
-<notes>{RESTNAME} {
+<chords,notes>{RESTNAME} {
const char *s = YYText ();
yylval.string = new String (s);
DOUT << "rest:"<< yylval.string;
return RESTNAME;
}
-<notes>R {
+<chords,notes>R {
return MEASURES;
}
<INITIAL,chords,lyrics,notes>\\\${BLACK}*{WHITE} {
yylval.i = String_convert::dec2_i (String (YYText ()));
return UNSIGNED;
}
+ \" {
+ start_quote ();
+ }
. {
return yylval.c = YYText ()[0];
}
#include "line-of-score.hh"
#include "spanner.hh"
-#include "atom.hh"
+
#include "paper-def.hh"
#include "p-col.hh"
#include "p-score.hh"
bool
Line_of_score::contains_b (Paper_column const* c) const
{
- return cols.find_l ((Paper_column*)c);
+ return cols_.find_l ((Paper_column*)(c));
}
Line_of_score*
Line_of_score::set_breaking (Array<Column_x_positions> const &breaking, int j) const
{
- const Array<Paper_column*> &curline (breaking[j].cols);
- const Array<Paper_column*> &errors (breaking[j].error_col_l_arr_);
+ const Link_array<Paper_column> &curline (breaking[j].cols);
+ const Link_array<Paper_column> &errors (breaking[j].error_col_l_arr_);
const Array<Real> &config (breaking[j].config);
for (int i=0; i < errors.size(); i++)
line_l = dynamic_cast <Line_of_score*> (clone());
}
else
- line_l = (Line_of_score*) this;
-
- ((Array<Paper_column*> &)line_l->cols) = curline;
+ line_l = (Line_of_score*)( this);
+
+ line_l->cols_ = curline;
+ /* Array<Paper_column*> &
+ ((Array<Paper_column*> &)) = */
line_l->set_bounds(LEFT,curline[0]);
line_l->set_bounds(RIGHT,curline.top());
for (int i=0; i < curline.size(); i++)
{
curline[i]->translate_axis (config[i],X_AXIS);
- curline[i]->line_l_ = (Line_of_score*)line_l;
+ curline[i]->line_l_ = dynamic_cast<Line_of_score*>(line_l);
}
return line_l;
Line_of_score::get_extra_dependencies () const
{
Link_array<Score_element> r;
- for (int i=0; i < cols.size (); i++)
- r.push (cols[i]);
+ for (int i=0; i < cols_.size (); i++)
+ r.push (cols_[i]);
return r;
}
Line_of_score::do_unlink ()
{
Spanner::do_unlink ();
- for (int i=0; i < cols.size (); i++)
- cols[i]->line_l_ =0;
- cols.set_size (0);
+ for (int i=0; i < cols_.size (); i++)
+ cols_[i]->line_l_ =0;
+ cols_.set_size (0);
}
void
Line_of_score::do_junk_links ()
{
- cols.set_size (0);
+ cols_.set_size (0);
}
#include "afm.hh"
#include "scope.hh"
#include "molecule.hh"
+#include "atom.hh"
SCM
array_to_list (SCM *a , int l)
}
+Molecule
+Lookup::ledger_line (Interval xwid) const
+{
+ Molecule end (afm_find ("noteheads-ledgerending"));
+ Interval ed = end.dim_[X_AXIS];
+ xwid = Interval (xwid[LEFT] - ed[LEFT],
+ xwid[RIGHT] - ed[RIGHT]);
+ Molecule mid = filledbox (Box (xwid, end.dim_[Y_AXIS]));
+ Molecule l (mid);
+
+ Molecule e2 = end;
+ Molecule e1 = end;
+ e1.translate_axis (xwid[RIGHT], X_AXIS);
+ e2.translate_axis (xwid[LEFT], X_AXIS);
+
+ l.add_molecule (e1);
+ l.add_molecule (e2);
+ return l;
+}
+
Molecule
Lookup::accidental (int j, bool cautionary) const
{
- Molecule m(afm_find (String ("accidentals") + String ("-") + to_str (j)));
+ Molecule m(afm_find (String ("accidentals-") + to_str (j)));
if (cautionary)
{
- Atom open = afm_find (String ("accidentals") + String ("-("));
- Atom close = afm_find (String ("accidentals") + String ("-)"));
+ Molecule open = afm_find (String ("accidentals-("));
+ Molecule close = afm_find (String ("accidentals-)"));
m.add_at_edge(X_AXIS, LEFT, Molecule(open), 0);
m.add_at_edge(X_AXIS, RIGHT, Molecule(close), 0);
}
-Atom
+Molecule
Lookup::afm_find (String s, bool warn) const
{
if (!afm_l_)
{
- Lookup * me = ((Lookup*)this);
+ Lookup * me = (Lookup*)(this);
me->afm_l_ = all_fonts_global_p->find_afm (font_name_);
if (!me->afm_l_)
{
warning (_f("Search path %s\n", global_path.str ().ch_C()));
}
}
- Adobe_font_char_metric m = afm_l_->find_char (s, warn);
-
- Atom a;
- if (m.code () < 0)
- return a;
+ Adobe_font_char_metric cm = afm_l_->find_char (s, warn);
+ Molecule m;
+ if (cm.code () < 0)
+ return m;
- a.dim_ = m.dimensions();
-
- a.lambda_ = gh_list (ly_symbol ("char"),
- gh_int2scm (m.code ()),
- SCM_UNDEFINED);
- a.font_ = font_name_;
- return a;
+ Atom at (gh_list (ly_symbol ("char"),
+ gh_int2scm (cm.code ()),
+ SCM_UNDEFINED));
+ at.font_ = ly_symbol (font_name_.ch_C());
+ m.dim_ = cm.dimensions();
+ m.add_atom (&at);
+ return m;
}
-Atom
+Molecule
Lookup::ball (int j) const
{
if (j > 2)
j = 2;
- return afm_find (String ("balls") + String ("-") + to_str (j));
+ return afm_find (String ("noteheads-") + to_str (j));
}
-Atom
+Molecule
Lookup::simple_bar (String type, Real h) const
{
SCM thick = ly_symbol ("barthick_" + type);
{
w = paper_l_->get_realvar (thick);
}
-
- Atom a;
- a.lambda_ = gh_list (ly_symbol ("filledbox"),
- gh_double2scm (0),
- gh_double2scm (w),
- gh_double2scm (h/2),
- gh_double2scm (h/2),
- SCM_UNDEFINED);
-
- a.dim_[X_AXIS] = Interval(0,w);
- a.dim_[Y_AXIS] = Interval (-h/2, h/2);
- return a;
+
+ return filledbox (Box (Interval(0,w), Interval(-h/2, h/2)));
}
Molecule
Lookup::bar (String str, Real h) const
{
+ if (str == "[")
+ return staff_bracket (h);
+ else if (str == "{")
+ return staff_brace (h);
+
Real kern = paper_l_->get_var ("bar_kern");
Real thinkern = paper_l_->get_var ("bar_thinkern");
- Atom thin = simple_bar ("thin", h);
- Atom thick = simple_bar ("thick", h);
- Atom colon = afm_find ("dots-repeatcolon");
+ Molecule thin = simple_bar ("thin", h);
+ Molecule thick = simple_bar ("thick", h);
+ Molecule colon = afm_find ("dots-repeatcolon");
Molecule m;
-
+
if (str == "")
{
- return fill (Box (Interval(0,0),Interval (-h/2, h/2)));
+ return fill (Box (Interval(0, 0), Interval (-h/2, h/2)));
}
else if (str == "|")
{
else if (str == "|.")
{
m.add_at_edge (X_AXIS, LEFT, thick, 0);
- m.add_at_edge (X_AXIS, LEFT, thin,kern);
+ m.add_at_edge (X_AXIS, LEFT, thin, kern);
}
else if (str == ".|")
{
}
else if (str == "|:")
{
- m.add_at_edge (X_AXIS, RIGHT, thick,0);
- m.add_at_edge (X_AXIS, RIGHT, thin,kern);
- m.add_at_edge (X_AXIS, RIGHT, colon,kern);
+ m.add_at_edge (X_AXIS, RIGHT, thick, 0);
+ m.add_at_edge (X_AXIS, RIGHT, thin, kern);
+ m.add_at_edge (X_AXIS, RIGHT, colon, kern);
}
else if (str == ":|:")
{
- m.add_at_edge (X_AXIS, LEFT, thick,thinkern);
- m.add_at_edge (X_AXIS, LEFT, colon,kern);
- m.add_at_edge (X_AXIS, RIGHT, thick,kern);
- m.add_at_edge (X_AXIS, RIGHT, colon,kern);
- }
- else if (str == "||")
- {
- m.add_at_edge (X_AXIS, RIGHT, thin,0);
- m.add_at_edge (X_AXIS, RIGHT, thin,thinkern);
+ m.add_at_edge (X_AXIS, LEFT, thick, thinkern);
+ m.add_at_edge (X_AXIS, LEFT, colon, kern);
+ m.add_at_edge (X_AXIS, RIGHT, thick, kern);
+ m.add_at_edge (X_AXIS, RIGHT, colon, kern);
}
-
else if (str == ".|.")
{
- m.add_at_edge (X_AXIS, RIGHT, thick, 0);
+ m.add_at_edge (X_AXIS, LEFT, thick, thinkern);
m.add_at_edge (X_AXIS, RIGHT, thick, kern);
}
+ else if (str == "||")
+ {
+ m.add_at_edge (X_AXIS, RIGHT, thin, 0);
+ m.add_at_edge (X_AXIS, RIGHT, thin, thinkern);
+ }
return m;
}
-Atom
+Molecule
Lookup::beam (Real slope, Real width, Real thick) const
{
Real height = slope * width;
Real min_y = (0 <? height) - thick/2;
Real max_y = (0 >? height) + thick/2;
- Atom a;
- a.lambda_ = gh_list (ly_symbol ("beam"),
- gh_double2scm (width),
- gh_double2scm (slope),
- gh_double2scm (thick),
- SCM_UNDEFINED);
-
- a.dim_[X_AXIS] = Interval (0, width);
- a.dim_[Y_AXIS] = Interval (min_y, max_y);
- return a;
+
+ Molecule m;
+ Atom at
+ (gh_list (ly_symbol ("beam"),
+ gh_double2scm (width),
+ gh_double2scm (slope),
+ gh_double2scm (thick),
+ SCM_UNDEFINED));
+
+ m.dim_[X_AXIS] = Interval (0, width);
+ m.dim_[Y_AXIS] = Interval (min_y, max_y);
+ m.add_atom (&at);
+ return m;
}
-Atom
+Molecule
Lookup::clef (String st) const
{
- return afm_find (String ("clefs") + String ("-") + st);
+ return afm_find (String ("clefs-" + st));
}
SCM
SCM_UNDEFINED);
}
-Atom
+Molecule
Lookup::dashed_slur (Array<Offset> controls, Real thick, Real dash) const
{
assert (controls.size () == 8);
Real dx = d[X_AXIS];
Real dy = d[Y_AXIS];
- Atom a;
- a.font_ = font_name_;
- a.dim_[X_AXIS] = Interval (0, dx);
- a.dim_[Y_AXIS] = Interval (0 <? dy, 0 >? dy);
+ Molecule m;
+
+
+ m.dim_[X_AXIS] = Interval (0, dx);
+ m.dim_[Y_AXIS] = Interval (0 <? dy, 0 >? dy);
SCM sc[4];
for (int i=0; i< 4; i++)
sc[i] = offset2scm (controls[i]);
}
- a.lambda_ =
- gh_list (ly_symbol ("dashed-slur"),
- gh_double2scm (thick),
- gh_double2scm (dash),
- ly_quote_scm (array_to_list (sc, 4)),
- SCM_UNDEFINED);
-
- return a;
+ Atom at
+ (gh_list (ly_symbol ("dashed-slur"),
+ gh_double2scm (thick),
+ gh_double2scm (dash),
+ ly_quote_scm (array_to_list (sc, 4)),
+ SCM_UNDEFINED));
+
+
+ m.add_atom (&at);
+ return m;
}
-Atom
+Molecule
Lookup::dots () const
{
- return afm_find (String ("dots") + String ("-") + String ("dot"));
+ return afm_find (String ("dots-dot"));
}
-Atom
-Lookup::extender (Real width) const
-{
- Atom a;
- a.lambda_ = gh_list (ly_symbol ("extender"),
- gh_double2scm (width),
- SCM_UNDEFINED);
- a.dim_[X_AXIS] = Interval (0, width);
- a.dim_[Y_AXIS] = Interval (0,0);
-
- a.font_ = font_name_;
- return a;
-}
-
-Atom
+Molecule
Lookup::fill (Box b) const
{
- Atom a;
- a.dim_ = b;
- return a;
+ Molecule m;
+ m.dim_ = b;
+ return m;
}
-Atom
+Molecule
Lookup::flag (int j, Direction d) const
{
char c = (d == UP) ? 'u' : 'd';
- Atom a = afm_find (String ("flags") + String ("-") + to_str (c) + to_str (j));
- return a;
+ return afm_find (String ("flags-") + to_str (c) + to_str (j));
}
-Atom
+Molecule
Lookup::rest (int j, bool o) const
{
- return afm_find (String ("rests")
- + String ("-") + to_str (j) + (o ? "o" : ""));
+ return afm_find (String ("rests-") + to_str (j) + (o ? "o" : ""));
}
-Atom
+Molecule
Lookup::rule_symbol (Real height, Real width) const
{
- Atom a;
- a.lambda_ = gh_list (ly_symbol ("rulesym"),
- gh_double2scm (height),
- gh_double2scm (width),
- SCM_UNDEFINED);
- a.dim_.x () = Interval (0, width);
- a.dim_.y () = Interval (0, height);
- return a;
+ Atom at (gh_list (ly_symbol ("rulesym"),
+ gh_double2scm (height),
+ gh_double2scm (width),
+ SCM_UNDEFINED));
+
+ Molecule m;
+ m.dim_.x () = Interval (0, width);
+ m.dim_.y () = Interval (0, height);
+
+ m.add_atom (&at);
+
+ return m;
}
-Atom
+Molecule
Lookup::script (String str) const
{
- return afm_find (String ("scripts") + String ("-") + str);
+ return afm_find (String ("scripts-") + str);
}
-Atom
-Lookup::special_time_signature (String s, Array<int> arr) const
+Molecule
+Lookup::special_time_signature (String s, int n, int d) const
{
// First guess: s contains only the signature style
- assert (arr.size () >1);
- String symbolname = "timesig-" + s + to_str (arr[0]) + "/" + to_str (arr[1]);
+ String symbolname = "timesig-" + s + to_str (n) + "/" + to_str (d);
- Atom a = afm_find (symbolname, false);
- if (!a.empty ())
- return a;
+ Molecule m = afm_find (symbolname, false);
+ if (!m.dim_[X_AXIS].empty_b ())
+ return m;
// Second guess: s contains the full signature name
- a = afm_find ("timesig-"+s, false);
- if (!a.empty ())
- return a;
+ m = afm_find ("timesig-"+s, false);
+ if (!m.dim_[X_AXIS].empty_b ())
+ return m;
// Resort to default layout with numbers
- return time_signature (arr);
+ return time_signature (n,d);
}
-Atom
+Molecule
+Lookup::filledbox (Box b ) const
+{
+ Molecule m;
+
+ Atom at (gh_list (ly_symbol ("filledbox"),
+ gh_double2scm (-b[X_AXIS][LEFT]),
+ gh_double2scm (b[X_AXIS][RIGHT]),
+ gh_double2scm (-b[Y_AXIS][DOWN]),
+ gh_double2scm (b[Y_AXIS][UP]),
+ SCM_UNDEFINED));
+
+ m.dim_ = b;
+ m.add_atom (&at);
+ return m;
+}
+
+Molecule
Lookup::stem (Real y1, Real y2) const
{
if (y1 > y2)
y1 = y2;
y2 = t;
}
- Atom a;
-
- a.dim_.x () = Interval (0,0);
- a.dim_.y () = Interval (y1,y2);
-
Real stem_width = paper_l_->get_var ("stemthickness");
-
- a.lambda_ = gh_list (ly_symbol ("filledbox"),
- gh_double2scm(stem_width /2),
- gh_double2scm(stem_width/2),
- gh_double2scm(y2),
- gh_double2scm(-y1),
- SCM_UNDEFINED);
-
- a.font_ = font_name_;
- return a;
+ return filledbox (Box (Interval (-stem_width/2,stem_width/2),
+ Interval (y1, y2)));
}
-Atom
-Lookup::streepje (int type) const
-{
- if (type > 2)
- type = 2;
-
- return afm_find ("balls" + String ("-") +to_str (type) + "l");
-}
static Dict_initialiser<char const*> cmr_init[] = {
{"bold", "cmbx"},
{"large", "cmbx"},
{"Large", "cmbx"},
{"mark", "feta-nummer"},
- {"nummer", "feta-nummer"},
+ {"number", "feta-nummer"},
{0,0}
};
static Dictionary<char const *> cmr_dict (cmr_init);
-Atom
+Molecule
Lookup::text (String style, String text) const
{
- Atom a;
- a.lambda_ = gh_list(ly_symbol ("set" + style),
- gh_str02scm (text.ch_C()),
- SCM_UNDEFINED);
+ Molecule m;
+
Real font_h = paper_l_->get_var ("font_normal");
if (paper_l_->scope_p_->elem_b ("font_" + style))
{
font_h = paper_l_->get_var ("font_" + style);
}
-
+
if (cmr_dict.elem_b (style))
{
style = String (cmr_dict [style]) + to_str ((int)font_h); // ugh
}
DOUT << "\n" << to_str (w) << "\n";
- a.dim_.x () = Interval (0, w);
- a.dim_.y () = ydims;
- a.font_ = font_name_;
- return a;
+ m.dim_.x () = Interval (0, w);
+ m.dim_.y () = ydims;
+ Atom at (gh_list (ly_symbol ("text"),
+ gh_str02scm (text.ch_C()),
+ SCM_UNDEFINED));
+ at.font_ = ly_symbol (style);
+
+ m.add_atom (&at);
+ return m;
}
/*
- TODO: should return a molecule with 2 stacked nums.
*/
-Atom
-Lookup::time_signature (Array<int> a) const
+Molecule
+Lookup::time_signature (int num, int den) const
{
- Atom s;
- s.lambda_ = gh_list (ly_symbol ("generalmeter"),
- gh_int2scm (a[0]),
- gh_int2scm (a[1]),
- SCM_UNDEFINED);
-
- Real r = paper_l_->interline_f () ;
- s.dim_[Y_AXIS] = Interval (-2*r, 2*r);
- s.dim_[X_AXIS] = Interval (0, 2*r);
- return s;
+ String sty = "number";
+ Molecule n (text (sty, to_str (num)));
+ Molecule d (text (sty, to_str (den)));
+ n.do_center (X_AXIS);
+ d.do_center (X_AXIS);
+ Molecule m;
+ if (den)
+ {
+ m.add_at_edge (Y_AXIS, UP, n, 0.0);
+ m.add_at_edge (Y_AXIS, DOWN, d, 0.0);
+ }
+ else
+ {
+ m = n;
+ m.do_center (Y_AXIS);
+ }
+ return m;
}
-Atom
-Lookup::vbrace (Real &y) const
+Molecule
+Lookup::staff_brace (Real y) const
{
- Atom a;
- a.lambda_ = gh_list (ly_symbol ("pianobrace"),
+ Molecule m;
+
+ Atom at (gh_list (ly_symbol ("pianobrace"),
gh_double2scm (y),
SCM_UNDEFINED
- );
- a.dim_[Y_AXIS] = Interval (-y/2,y/2);
- a.dim_[X_AXIS] = Interval (0,0);
- a.font_ = font_name_;
- return a;
+ ));
+
+ m.dim_[Y_AXIS] = Interval (-y/2,y/2);
+ m.dim_[X_AXIS] = Interval (0,0);
+ m.add_atom (&at);
+ return m;
}
-Atom
+Molecule
Lookup::hairpin (Real width, bool decresc, bool continued) const
{
- Atom a;
+ Molecule m;
Real height = paper_l_->staffheight_f () / 6;
String hairpin = String (decresc ? "de" : "") + "crescendo";
- a.lambda_ = gh_list (ly_symbol (hairpin),
+ Atom at (gh_list (ly_symbol (hairpin),
gh_double2scm (width),
gh_double2scm (height),
gh_double2scm (continued ? height/2 : 0.0),
- SCM_UNDEFINED);
- a.dim_.x () = Interval (0, width);
- a.dim_.y () = Interval (-2*height, 2*height);
- a.font_ = font_name_;
- return a;
+ SCM_UNDEFINED));
+ m.dim_.x () = Interval (0, width);
+ m.dim_.y () = Interval (-2*height, 2*height);
+
+ m.add_atom (&at);
+ return m;
}
-Atom
+Molecule
Lookup::plet (Real dy , Real dx, Direction dir) const
{
- Atom a;
+ Molecule m;
SCM thick = ly_symbol ("tuplet_thick");
Real t = 0.1 PT;
if (paper_l_->scope_p_->elem_b (thick))
{
t = paper_l_->get_realvar (thick);
}
- a.lambda_ = gh_list(ly_symbol ("tuplet"),
+
+ Atom at (gh_list(ly_symbol ("tuplet"),
gh_double2scm (dx),
gh_double2scm (dy),
gh_double2scm (t),
gh_int2scm (dir),
- SCM_UNDEFINED);
- return a;
-}
+ SCM_UNDEFINED));
+m.add_atom (&at);
+ return m;
+}
-Atom
+/*
+ Make a smooth curve along the points
+ */
+Molecule
Lookup::slur (Array<Offset> controls) const
{
- assert (controls.size () == 8);
- Real dx = controls[3].x () - controls[0].x ();
- Real dy = controls[3].y () - controls[0].y ();
- Atom a;
+ Offset delta_off = controls[3]- controls[0];
+ Molecule m;
SCM scontrols [8];
int indices[] = {5,6,7,4,1,2,3,0};
scontrols[i] = offset2scm (controls[indices[i]]);
- a.lambda_ =gh_list (ly_symbol ("slur"),
+ Atom at (gh_list (ly_symbol ("bezier-sandwich"),
ly_quote_scm (array_to_list (scontrols, 8)),
- SCM_UNDEFINED);
+ SCM_UNDEFINED));
- a.dim_[X_AXIS] = Interval (0, dx);
- a.dim_[Y_AXIS] = Interval (0 <? dy, 0 >? dy);
- a.font_ = font_name_;
- return a;
+ m.dim_[X_AXIS] = Interval (0, delta_off[X_AXIS]);
+ m.dim_[Y_AXIS] = Interval (0 <? delta_off[Y_AXIS], 0 >? delta_off[Y_AXIS]);
+ m.add_atom (&at);
+ return m;
}
-Atom
-Lookup::vbracket (Real &y) const
+Molecule
+Lookup::staff_bracket (Real y) const
{
- Atom a;
- a.lambda_ = gh_list (ly_symbol ("bracket"),
+ Molecule m;
+ Atom at ( gh_list (ly_symbol ("bracket"),
gh_double2scm (y),
- SCM_UNDEFINED);
- a.dim_[Y_AXIS] = Interval (-y/2,y/2);
- a.dim_[X_AXIS] = Interval (0,4 PT);
- return a;
+ SCM_UNDEFINED));
+ m.add_atom (&at);
+ m.dim_[Y_AXIS] = Interval (-y/2,y/2);
+ m.dim_[X_AXIS] = Interval (0,4 PT);
+
+ m.translate_axis (- 4. / 3. * m.dim_[X_AXIS].length (), X_AXIS);
+ return m;
}
-Atom
+Molecule
Lookup::volta (Real w, bool last_b) const
{
- Atom a;
+ Molecule m;
SCM thick = ly_symbol ("volta_thick");
Real t = 0.1 PT;
if (paper_l_->scope_p_->elem_b (thick))
{
t = paper_l_->get_realvar (thick);
}
- a.lambda_ = gh_list (ly_symbol ("volta"),
+ Atom at (gh_list (ly_symbol ("volta"),
gh_double2scm (w),
gh_double2scm (t),
gh_int2scm (last_b),
- SCM_UNDEFINED);
+ SCM_UNDEFINED));
Real interline_f = paper_l_->interline_f ();
- a.dim_[Y_AXIS] = Interval (-interline_f, interline_f);
- a.dim_[X_AXIS] = Interval (0, w);
- return a;
+ m.dim_[Y_AXIS] = Interval (-interline_f, interline_f);
+ m.dim_[X_AXIS] = Interval (0, w);
+
+ m.add_atom (&at);
+ return m;
}
-Atom
+Molecule
Lookup::special_ball (int j, String kind_of_ball) const
{
if (j > 2)
j = 2;
- return afm_find (String ("balls") + String ("-") + kind_of_ball);
+ return afm_find (String ("noteheads-") + kind_of_ball);
}
+
#include "lily-guile.hh"
#include "paper-def.hh"
#include "midi-def.hh"
+#include "global-ctor.hh"
#if HAVE_GETTEXT
#include <libintl.h>
void
main_prog (int argc, char **argv)
{
+ /*
+ need to do this first. Engravers use lily.scm contents.
+ */
+ read_lily_scm_file ( "lily.scm");
+ cout << endl;
+
call_constructors ();
default_outname_base_global = "lelie";
all_fonts_global_p = new All_font_metrics (global_path.str ());
}
Real
-Midi_def::duration_to_seconds_f (Moment mom)
+Midi_def::length_mom_to_seconds_f (Moment mom)
{
if (!mom)
return 0;
}
Moment
-Midi_note::duration () const
+Midi_note::length_mom () const
{
- Moment m = dynamic_cast <Rhythmic_req *> (audio_item_l_->req_l_)->duration ();
+ Moment m = dynamic_cast <Rhythmic_req *> (audio_item_l_->req_l_)->length_mom ();
if (m < Moment (1, 1000))
{
warning (_ ("silly duration"));
Midi_note::pitch_i () const
{
int p = dynamic_cast <Melodic_req*> (audio_item_l_->req_l_)->pitch_.semitone_pitch ()
- + ((Audio_note*)audio_item_l_)->transposing_i_;
+ + dynamic_cast<Audio_note*>(audio_item_l_)->transposing_i_;
if (p == INT_MAX)
{
warning (_ ("silly pitch"));
Midi_note_off::pitch_i () const
{
return dynamic_cast <Melodic_req *> (audio_item_l_->req_l_)->pitch_.semitone_pitch ()
- + ((Audio_note*)audio_item_l_)->transposing_i_;
+ + dynamic_cast<Audio_note*>(audio_item_l_)->transposing_i_;
}
String
Midi_tempo::Midi_tempo (Audio_item* audio_item_l)
: Midi_item (audio_item_l)
{
- per_minute_4_i_ = ( (Audio_tempo*)audio_item_l_)->per_minute_4_i_;
+ per_minute_4_i_ = dynamic_cast<Audio_tempo*>(audio_item_l_)->per_minute_4_i_;
}
Midi_tempo::Midi_tempo (int per_minute_4_i)
Midi_text::Midi_text (Audio_item* audio_item_l)
: Midi_item (audio_item_l)
{
- text_str_ = ( (Audio_text*)audio_item_l_)->text_str_;
- type_ = (Type) ( (Audio_text*)audio_item_l_)->type_;
+ text_str_ = dynamic_cast<Audio_text*>(audio_item_l_)->text_str_;
+ type_ = (Type) dynamic_cast<Audio_text*>(audio_item_l_)->type_;
}
Midi_text::Midi_text (Midi_text::Type type, String text_str)
void
Midi_walker::do_start_note (Midi_note* note_p)
{
- Moment stop_mom = note_p->duration() + ptr ()->audio_column_l_->at_mom ();
+ Moment stop_mom = note_p->length_mom () + ptr ()->audio_column_l_->at_mom ();
for (int i=0; i < stop_note_queue.size(); i++)
{
if (stop_note_queue[i].val->pitch_i() == note_p->pitch_i ())
#include "molecule.hh"
#include "atom.hh"
#include "debug.hh"
+#include "killing-cons.tcc"
Box
Molecule::extent() const
{
- Box b;
- for (iter_top (atoms_,c); c.ok(); c++)
- b.unite (c->extent());
- return b;
+ return dim_;
}
Interval
Molecule::extent(Axis a) const
{
- Interval i;
- for (iter_top (atoms_,c); c.ok(); c++)
- i.unite (c->extent(a));
- return i;
+ return dim_[a];
}
void
Molecule::translate (Offset o)
{
- for (iter_top (atoms_,c); c.ok(); c++)
- c->translate (o);
+ for (Cons<Atom> * ptr = atom_list_; ptr; ptr = ptr->next_)
+ {
+ ptr->car_->off_ += o;
+ }
+ dim_.translate (o);
}
void
Molecule::translate_axis (Real x,Axis a)
{
- for (iter_top (atoms_,c); c.ok(); c++)
- c->translate_axis (x,a);
+ for (Cons<Atom> * ptr = atom_list_; ptr; ptr = ptr->next_)
+ {
+ ptr->car_->off_[a] += x;
+ }
+ dim_[a] += x;
}
void
Molecule::add_molecule (Molecule const &m)
{
- for (iter_top (m.atoms_,c); c.ok(); c++)
+ for (Cons<Atom> * ptr = m.atom_list_; ptr; ptr = ptr->next_)
{
- add_atom (**c);
+ add_atom (ptr->car_);
}
-}
+ dim_.unite (m.dim_);
+}
void
-Molecule::add_at_edge (Axis a, Direction d, Molecule const &m, Real padding)
+Molecule::add_atom (Atom const *al)
{
- Real my_extent= atoms_.size()
- ? extent ()[a][d]
- : 0.0;
-
- Real offset = my_extent - m.extent ()[a][-d];
- Molecule toadd (m);
- toadd.translate_axis (offset + d * padding, a);
- add_molecule (toadd);
+ Atom *a = new Atom(*al);
+
+ atom_list_ = new Killing_cons<Atom> (a, atom_list_);
}
-
-
void
-Molecule::operator = (Molecule const &)
+Molecule::operator=(Molecule const & src)
{
- assert (false);
+ if (&src == this) return;
+ delete atom_list_;
+ atom_list_ = 0;
+ dim_= src.dim_;
+ add_molecule (src);
}
Molecule::Molecule (Molecule const &s)
{
+ atom_list_ = 0;
add_molecule (s);
}
+Molecule::~Molecule ()
+{
+ delete atom_list_;
+}
+
void
Molecule::print() const
{
#ifndef NPRINT
if (! check_debug)
return;
- for (iter_top (atoms_,c); c.ok(); c++)
- c->print();
+ DOUT << "dim:";
+ for (Axis i=X_AXIS; i < NO_AXES; incr (i))
+ DOUT << axis_name_str (i) << " = " << dim_[i].str ();
#endif
}
void
-Molecule::add_atom (Atom const &a)
+Molecule::do_center (Axis a)
{
- atoms_.bottom().add (new Atom (a));
+ Interval i (extent (a));
+ translate_axis (-i.center (), a);
}
-Molecule::Molecule (Atom const &a)
+Molecule::Molecule ()
+{
+ dim_ = Box (Interval(0,0),Interval( 0,0 ));
+ atom_list_ = 0;
+}
+
+
+void
+Molecule::add_at_edge (Axis a, Direction d, Molecule const &m, Real padding)
{
- add_atom (a) ;
+ Real my_extent= dim_[a][d];
+
+ Real offset = my_extent - m.extent ()[a][-d];
+ Molecule toadd (m);
+ toadd.translate_axis (offset + d * padding, a);
+ add_molecule (toadd);
}
{
if (multi_measure_req_l_)
if (!multi_measure_req_l_->equal_b (mr)
- || rest_moments_[START] != now_moment ())
+ || rest_moments_[START] != now_mom ())
return false;
multi_measure_req_l_ = mr;
- rest_moments_[START] = now_moment ();
+ rest_moments_[START] = now_mom ();
- rest_moments_[STOP] = rest_moments_[START] + multi_measure_req_l_->duration_.length ();
+ rest_moments_[STOP] = rest_moments_[START] + multi_measure_req_l_->duration_.length_mom ();
return true;
}
return false;
void
Multi_measure_rest_engraver::do_pre_move_processing ()
{
- Moment now (now_moment ());
+ Moment now (now_mom ());
Time_description const *time = get_staff_info().time_C_;
if (mmrest_p_ && (now >= rest_moments_[START])
&& !time->whole_in_measure_
Multi_measure_rest_engraver::do_post_move_processing ()
{
Time_description const *time = get_staff_info().time_C_;
- Moment now (now_moment ());
+ Moment now (now_mom ());
if (mmrest_p_ && !time->whole_in_measure_)
{
if (!column_arr_.size ())
return mol_p;
- Atom s;
+ Molecule s;
if (measures_i_ == 1 || measures_i_ == 2 || measures_i_ == 4)
{
s = (lookup_l ()->rest (- intlog2(measures_i_), 0));
{
s = (lookup_l ()->rest (-4, 0));
}
- mol_p->add_atom (s);
+ mol_p->add_molecule (s);
Real interline_f = paper ()->interline_f ();
if (measures_i_ == 1)
{
text.text_str_ = to_str (measures_i_);
text.style_str_ = "number";
text.align_dir_ = CENTER;
- Atom s = text.get_atom (paper (), UP);
+ Molecule s = text.get_molecule (paper (), UP);
s.translate_axis (3.0 * interline_f, Y_AXIS);
- mol_p->add_atom (s);
+ mol_p->add_molecule (s);
}
return mol_p;
#include "main.hh"
Moment
-Simultaneous_music::duration () const
+Simultaneous_music::length_mom () const
{
Moment dur = 0;
for (iter (music_p_list_p_->top(), i); i.ok (); i++)
- dur = dur >? i->duration ();
+ dur = dur >? i->length_mom ();
return dur;
}
}
Moment
-Sequential_music::duration () const
+Sequential_music::length_mom () const
{
Moment last=0;
for (iter (music_p_list_p_->top(), i); i.ok (); i++)
{
- last += i->duration ();
+ last += i->length_mom ();
}
return last;
}
void
Music_wrapper_iterator::construct_children ()
{
- child_iter_p_ = get_iterator_p (music_wrapper_l ()->element_l ());
+ child_iter_p_ =
+ get_iterator_p (dynamic_cast<Music_wrapper const*> (music_l_)->element_l ());
}
Music_wrapper_iterator::~Music_wrapper_iterator ()
delete child_iter_p_;
}
-Music_wrapper*
-Music_wrapper_iterator::music_wrapper_l () const
-{
- return (Music_wrapper*) music_l_;
-}
bool
Music_wrapper_iterator::ok () const
Moment
-Music_wrapper::duration () const
+Music_wrapper::length_mom () const
{
- return element_p_->duration ();
+ return element_p_->length_mom ();
}
}
Moment
-Music::duration () const
+Music::length_mom () const
{
return 0;
}
pitch_.print ();
}
+
+Tonic_req::Tonic_req ()
+{
+}
+
+void
+Tonic_req::do_print () const
+{
+#ifndef NPRINT
+ Melodic_req::do_print ();
+#endif
+}
+
int
Rhythmic_req::compare (Rhythmic_req const &r1, Rhythmic_req const &r2)
{
- return (r1.duration () - r2.duration ());
+ return (r1.length_mom () - r2.length_mom ());
}
bool
Moment
-Rhythmic_req::duration () const
+Rhythmic_req::length_mom () const
{
- return duration_.length ();
+ return duration_.length_mom ();
}
void
Skip_req::do_print () const
{
#ifndef NPRINT
- DOUT << "duration: " << duration ();
+ DOUT << "duration: " << length_mom ();
#endif
}
Absolute_dynamic_req::do_print () const
{
#ifndef NPRINT
- Dynamic_req::do_print ();
- DOUT << " loudness " <<loudness_str ();
+ DOUT << " loudness " <<loudness_str_ ;
#endif
}
Absolute_dynamic_req::do_equal_b (Request *r) const
{
Absolute_dynamic_req *a = dynamic_cast <Absolute_dynamic_req *> (r);
- return a&& loudness_ == a->loudness_;
+ return a&& loudness_str_ == a->loudness_str_;
}
-String
-Dynamic_req::loudness_static_str (Loudness l)
-{
- switch (l)
- {
- case FFFFFF: return "ffffff";
- case FFFFF : return "fffff";
- case FFFF: return "ffff";
- case FFF: return "fff";
- case FF: return "ff";
- case F: return "f";
- case MF: return "mf";
- case MP: return "mp";
- case P: return "p";
- case PP: return "pp";
- case PPP: return "ppp";
- case PPPP: return "pppp";
- case PPPPP: return "ppppp";
- case PPPPPP: return "pppppp";
-
- case FP: return "fp";
- case SF: return "sf";
- case SFF: return "sff";
- case SFZ: return "sfz";
- case SP: return "sp";
- case SPP: return "spp";
- case RFZ: return "rfz";
- }
- return "";
-}
-
-String
-Absolute_dynamic_req::loudness_str () const
-{
- String str = loudness_static_str (loudness_);
- if (str.empty_b ())
- {
- String s = "mf";
- warning (_f ("never heard of dynamic scale `\%s\', assuming %s",
- str, s));
- str = s;
- }
- return str;
-}
-
-
Absolute_dynamic_req::Absolute_dynamic_req ()
{
- loudness_ = MF;
+ loudness_str_ = "fm"; // yes, "illegal" on purpose.
}
Chord chord (tonic, add_arr_p, sub_arr_p, inversion_p);
+ Tonic_req* t = new Tonic_req;
+ t->pitch_ = tonic;
+ v->add_music (t);
+
for (int i = 0; i < chord.pitch_arr_.size (); i++)
{
Musical_pitch p = chord.pitch_arr_[i];
v->add_music (n);
}
- v->set_spot (here_input ());
return v;
}
/*
UGH.
*/
-Array<Request*>*
+Link_array<Request>*
My_lily_parser::get_parens_request (int t)
{
- Array<Request*>& reqs = *new Array<Request*>;
+ Link_array<Request>& reqs = *new Link_array<Request>;
switch (t)
{
case '~':
#include "rest.hh"
#include "debug.hh"
-
-
bool
Note_column::rest_b () const
{
return iv;
}
-/*
-Interval
-Note_column::do_width () const
-{
- if (head_l_arr_.size ())
- return head_l_arr_[0]->extent (X_AXIS);
- else
- return Interval (0,0);
-}
-*/
void
Note_column::do_pre_processing()
{
void
Note_column::add_head (Rhythmic_head *h)
{
- if (dynamic_cast<Rest *> (h))
+ if (Rest*r=dynamic_cast<Rest *> (h))
{
- rest_l_arr_.push ((Rest*)h);
- add_support (h);
+ rest_l_arr_.push (r);
+ add_support (r);
}
- if (dynamic_cast<Note_head *> (h))
+ if (Note_head *nh=dynamic_cast<Note_head *> (h))
{
- head_l_arr_.push ((Note_head*) h);
- add_support (h);
+ head_l_arr_.push (nh);
+ add_support (nh);
}
}
Interval
Note_head::do_width () const
{
- Atom a = lookup_l ()->ball (balltype_i_);
+ Molecule a = lookup_l ()->ball (balltype_i_);
Interval i = a.dim_[X_AXIS];
i+= x_dir_ * i.length ();
return i;
? 0
: (abs(position_i_) - staff_size_i_/2) /2;
- //Atom s = lookup_l()->ball (balltype_i_);
-
- Atom s; // = lookup_l()->ball (balltype_i_);
+ Molecule head;
if (note_head_type_str_.length_i ()) {
- if (note_head_type_str_ == "normal")
+ if (note_head_type_str_ == "normal") // UGH
note_head_type_str_ = "";
- s = lookup_l()->special_ball (balltype_i_, note_head_type_str_);
+ head = lookup_l()->special_ball (balltype_i_, note_head_type_str_);
}
else
- s = lookup_l()->ball (balltype_i_);
- out = new Molecule (Atom (s));
- out->translate_axis (x_dir_ * s.dim_[X_AXIS].length (), X_AXIS);
+ head = lookup_l()->ball (balltype_i_);
+
+ out = new Molecule (Molecule (head));
+ out->translate_axis (x_dir_ * head.dim_[X_AXIS].length (), X_AXIS);
- //out = new Molecule (Atom (s));
- //out->translate_axis (x_dir_ * s.dim_[X_AXIS].length (), X_AXIS);
if (streepjes_i)
{
- int dir = sign (position_i_);
- Atom streepje = lookup_l ()->streepje (balltype_i_);
+ Direction dir = sign (position_i_);
+ Interval hd = head.dim_[X_AXIS];
+ Real hw = hd.length ()/4;
+
+ Molecule ledger
+ = lookup_l ()->ledger_line (Interval (hd[LEFT] - hw,
+ hd[RIGHT] + hw));
- int parity = (position_i_ % 2) ? 1 : 0;
-
+ int parity = abs(position_i_) % 2;
for (int i=0; i < streepjes_i; i++)
{
- Atom s = streepje;
+ Molecule s (ledger);
s.translate_axis (-dir * inter_f * (i*2 + parity),
Y_AXIS);
- out->add_atom (s);
+ out->add_molecule (s);
}
}
Paper_column*
Paper_column::prebreak_l() const
{
- return (Paper_column*)broken_to_drul_[LEFT];
+ return dynamic_cast<Paper_column*>(broken_to_drul_[LEFT]);
}
Paper_column*
Paper_column::postbreak_l() const
{
- return(Paper_column*) broken_to_drul_[RIGHT];
+ return dynamic_cast<Paper_column*>( broken_to_drul_[RIGHT]);
}
bool
Paper_column::breakpoint_b() const
Paper_column*
Paper_column::column_l () const
{
- return (Paper_column*)this;
+ return (Paper_column*)(this);
}
}
-#if 0
-void
-Paper_score::set_breaking (Array<Column_x_positions> const &breaking)
-{
- for (iter (span_p_list_.top (),i); i.ok ();)
- {
- Spanner *span_p = i.remove_p ();
- if (span_p->broken_b ()
- || !((Score_element*)span_p)->line_l ())
- {
- span_p->unlink ();
- delete span_p;
- }
- else
- {
- typeset_broken_spanner (span_p);
- }
- }
- for (iter (elem_p_list_.top (),i); i.ok () ;)
- {
- Item *i_l =dynamic_cast <Item *> (i);
- if (i_l && !i_l->line_l ())
- {
- i_l->unlink ();
- Score_element * item_p= i.remove_p ();
- delete item_p;
- }
- else
- i++;
- }
-}
-#endif
Array<Column_x_positions>
}
Real
-Paper_def::duration_to_dist (Moment d,Real k) const
+Paper_def::length_mom_to_dist (Moment d,Real k) const
{
return arithmetic_spacing (d,k);
}
#include "paper-outputter.hh"
#include "paper-stream.hh"
#include "molecule.hh"
-#include "atom.hh"
#include "array.hh"
#include "string-convert.hh"
#include "debug.hh"
#include "scope.hh"
#include "identifier.hh"
#include "lily-version.hh"
+#include "atom.hh"
Paper_outputter::Paper_outputter (Paper_stream *s)
{
void
Paper_outputter::output_header ()
{
-
+#if 0
+ int gobble = 10000;
+ {// alloc big chunk of memory.
+ SCM beg = SCM_EOL;
+ String bigstr = String_convert::char_str (' ', 50);
+ for (int i = gobble; i--; )
+ {
+ beg = gh_cons (gh_str02scm (bigstr.ch_C()), beg);
+ }
+ }
+#endif
+
if (safe_global_b)
{
ly_set_scm ("security-paranoia", SCM_BOOL_T);
if (check_debug)
*outstream_l_ << String ("\n%start: ") << nm << "\n";
- for (PCursor <Atom*> i (m->atoms_); i.ok (); i++)
+
+ if (check_debug)
{
- Offset a_off = i->offset ();
+ output_comment (nm);
+ }
+
+
+ for (Cons<Atom> *ptr = m->atom_list_; ptr; ptr = ptr->next_)
+ {
+ Atom * i = ptr->car_;
+ Offset a_off = i->off_;
a_off += o;
- if (!i->lambda_)
+ if (!i->func_)
continue;
- if (check_debug)
+ if (i->font_)
{
- output_comment (classname (i.ptr ()->origin_l_));
-
+ output_scheme (gh_list (ly_symbol ("select-font"),
+ gh_str02scm (symbol_to_string (i->font_).ch_C()),
+ SCM_UNDEFINED));
}
-
- switch_to_font (i->font_);
-
- SCM args_scm = gh_list (gh_double2scm (a_off.x ()),
- gh_double2scm (a_off.y ()),
- i->lambda_.to_SCM (),
- SCM_UNDEFINED);
-
-
- SCM box_scm = gh_cons (ly_symbol ("placebox"), args_scm);
+ SCM box_scm
+ = gh_list (ly_symbol ("placebox"),
+ gh_double2scm (a_off.x ()),
+ gh_double2scm (a_off.y ()),
+ i->func_.to_SCM(),
+ SCM_UNDEFINED);
+
output_scheme (box_scm);
}
}
void
Paper_outputter::output_scheme (SCM scm)
{
- String o = String ("\'") + output_global_ch;
-
if (String (output_global_ch) == "scm")
{
static SCM port = 0;
output_String_def ( "LilyIdString", id_str);
}
-void
-Paper_outputter::switch_to_font (String fontname)
-{
- if (fontname.length_i () && fontname != current_font_)
- {
- current_font_ = fontname;
- int i=0;
-
- for (; i< font_arr_.size (); i++)
- if (font_arr_[i] == fontname)
- break;
-
- if (i == font_arr_.size ())
- {
- font_arr_.push (fontname);
- output_font_def (i, fontname);
- }
- output_font_switch (i);
- }
- return;
-}
-
void
Paper_outputter::start_line ()
{
gh_define (k.ch_l (), gh_int2scm (v));
}
-void
-Paper_outputter::output_font_switch (int i)
-{
- SCM scm = gh_list (ly_symbol ("font-switch"),
- gh_int2scm (i),
- SCM_UNDEFINED);
- output_scheme (scm);
-}
void
Paper_outputter::stop_line ()
{
SCM scm = gh_list (ly_symbol ("stop-line"), SCM_UNDEFINED);
output_scheme (scm);
-
- current_font_ = "";
- font_arr_.clear ();
}
$$-> assign_translator ($2);
}
| midi_body tempo_request ';' {
- $$->set_tempo ($2->dur_.length (), $2->metronome_i_);
+ $$->set_tempo ($2->dur_.length_mom (), $2->metronome_i_);
delete $2;
}
| midi_body error {
$$ = new Cadenza_req ($2);
}
| PARTIAL duration_length {
- $$ = new Partial_measure_req ($2->length ());
+ $$ = new Partial_measure_req ($2->length_mom ());
delete $2;
}
| CLEF STRING {
THIS->post_reqs.push ($2);
}
| post_requests close_request_parens {
- Array<Request*>& r = *THIS->get_parens_request ($2);
- for (int i = 0; i < r.size (); i++ )
- r[i]->set_spot (THIS->here_input ());
- THIS->post_reqs.concat (r);
- delete &r;
+ Link_array<Request> *r = THIS->get_parens_request ($2);
+ for (int i = 0; i < r->size (); i++ )
+ r->elem (i)->set_spot (THIS->here_input ());
+ THIS->post_reqs.concat (*r);
+ delete r;
}
;
};
dynamic_req:
- ABSDYNAMIC '{' unsigned '}' {
+ ABSDYNAMIC '{' STRING '}' {
Absolute_dynamic_req *ad_p = new Absolute_dynamic_req;
- ad_p ->loudness_ = (Dynamic_req::Loudness)$3;
+ ad_p ->loudness_str_ = *$3;
+ delete $3;
$$ =ad_p;
}
| SPANDYNAMIC '{' int int '}' {
}
| pre_requests open_request_parens {
-
- Array<Request*>& r = *THIS->get_parens_request ($2);
- for (int i = 0; i < r.size (); i++ )
- r[i]->set_spot (THIS->here_input ());
- THIS->pre_reqs.concat (r);
- delete &r;
+ Link_array<Request>* r = THIS->get_parens_request ($2);
+ for (int i = 0; i < r->size (); i++ )
+ r->elem (i)->set_spot (THIS->here_input ());
+ THIS->pre_reqs.concat (*r);
+ delete r;
}
;
Protected_scm::~Protected_scm ()
{
if (object_)
- scm_unprotect_object (object_);
+ {
+ scm_unprotect_object (object_);
+ object_ =0L; // be nice to conservative GC
+ }
}
-Protected_scm::operator SCM ()
+Protected_scm::operator SCM () const
{
return object_;
}
return true;
Music_sequence* alt = r->alternative_p_;
- Moment stop_mom = now_moment () + r->repeat_p_->duration ();
- for (PCursor<Music*> i (alt->music_p_list_p_->top ()); i.ok () && (i != alt->music_p_list_p_->bottom ()); i++)
+ Moment repeat_length_mom = r->repeat_p_->length_mom ();
+ Moment stop_mom = now_mom () + repeat_length_mom;
+ Moment alt_mom = now_mom () + repeat_length_mom;
+ if (repeat_length_mom)
{
- stop_mom += i->duration ();
- if (dynamic_cast<Simultaneous_music *> (alt))
- break;
+ for (PCursor<Music*> i (alt->music_p_list_p_->top ()); i.ok () && (i != alt->music_p_list_p_->bottom ()); i++)
+ {
+ stop_mom += i->length_mom ();
+ if (dynamic_cast<Simultaneous_music *> (alt))
+ break;
+ }
+ repeated_music_arr_.push (r);
+ stop_mom_arr_.push (stop_mom);
}
- Moment alt_mom = now_moment () + r->repeat_p_->duration ();
- /*
- TODO:
- figure out what we don't want.
-
- we don't want to print more than one set of
- |: :| and volta brackets on one staff.
- counting nested repeats, it seems safest to forbid
- two pieces of alternative music to start at the same time.
- */
+ /*
+ Counting nested repeats, it seems safest to forbid
+ two pieces of alternative music to start at the same time.
+ */
for (int i = 0; i < alternative_start_mom_arr_.size (); i++)
if (alternative_start_mom_arr_[i] == alt_mom)
return false;
- repeated_music_arr_.push (r);
- stop_mom_arr_.push (stop_mom);
+
+ /*
+ Coda kludge: see input/test/coda-kludge.ly
+ */
+ Moment span_mom;
+ Scalar prop = get_property ("voltaSpannerDuration", 0);
+ if (prop.length_i ())
+ span_mom = prop.to_rat ();
+ int alt_i = r->repeats_i_ + 1 - alt->music_p_list_p_->size () >? 1;
for (PCursor<Music*> i (alt->music_p_list_p_->top ()); i.ok (); i++)
{
alternative_music_arr_.push (i.ptr ());
alternative_start_mom_arr_.push (alt_mom);
- alternative_stop_mom_arr_.push (alt_mom + i->duration ());
+ if (span_mom)
+ alternative_stop_mom_arr_.push (alt_mom + span_mom);
+ else
+ alternative_stop_mom_arr_.push (alt_mom + i->length_mom ());
+ String str;
+ if ((alt_i != 1) && (alt_i != r->repeats_i_) && (i == alt->music_p_list_p_->top ()))
+ str = "1.-";
+ str += to_str (alt_i) + ".";
+ alt_i++;
+ alternative_str_arr_.push (str);
if (!dynamic_cast<Simultaneous_music *> (alt))
- alt_mom += i->duration ();
+ alt_mom += i->length_mom ();
}
return true;
}
void
Repeat_engraver::acknowledge_element (Score_element_info i)
{
- Moment now = now_moment ();
+ Moment now = now_mom ();
if (Note_column *c = dynamic_cast<Note_column *> (i.elem_l_))
{
for (int i = 0; i < volta_p_arr_.size (); i++)
void
Repeat_engraver::do_process_requests ()
{
- Moment now = now_moment ();
+ Moment now = now_mom ();
Bar_engraver* bar_engraver_l = dynamic_cast <Bar_engraver*>
(daddy_grav_l ()->get_simple_translator ("Bar_engraver"));
for (int i = bar_b_arr_.size (); i < repeated_music_arr_.size (); i++)
{
- if (bar_engraver_l && (now > Moment (0)))
+ if (bar_engraver_l)
bar_engraver_l->request_bar ("|:");
bar_b_arr_.push (true);
}
bar_engraver_l->request_bar (":|");
}
}
- int bees = volta_p_arr_.size ();
for (int i = volta_p_arr_.size (); i < alternative_music_arr_.size (); i++)
{
Volta_spanner* v = new Volta_spanner;
Scalar prop = get_property ("voltaVisibility", 0);
v->visible_b_ = prop.to_bool ();
- if (i == alternative_music_arr_.size () - 1)
+ prop = get_property ("voltaSpannerDuration", 0);
+ if ((i == alternative_music_arr_.size () - 1) || prop.length_i ())
v->last_b_ = true;
Text_def* t = new Text_def;
- t->text_str_ = to_str (i - bees + 1) + ".";
+ t->text_str_ = alternative_str_arr_[i];
v->number_p_.set_p (t);
volta_p_arr_.push (v);
announce_element (Score_element_info (v, alternative_music_arr_[i]));
void
Repeat_engraver::do_pre_move_processing ()
{
- Moment now = now_moment ();
+ Moment now = now_mom ();
for (int i = bar_b_arr_.size (); i--; )
{
if (bar_b_arr_[i])
alternative_music_arr_.del (i);
alternative_start_mom_arr_.del (i);
alternative_stop_mom_arr_.del (i);
+ alternative_str_arr_.del (i);
}
}
}
void
Repeat_engraver::do_post_move_processing ()
{
-#if 0
- Time_description const *time = get_staff_info().time_C_;
- Moment now = now_moment ();
- for (int i = volta_p_arr_.size (); i--; )
- {
- if ((now > alternative_stop_mom_arr_[i])
- && !time->whole_in_measure_)
- {
- volta_p_arr_[i] = 0;
- volta_p_arr_.del (i);
- alternative_music_arr_[i] = 0;
- alternative_music_arr_.del (i);
- alternative_start_mom_arr_.del (i);
- alternative_stop_mom_arr_.del (i);
- }
- }
-#endif
}
repeat_iter_p_ = 0;
alternative_iter_p_ = 0;
here_mom_ = 0;
-#if 0
- unfold_i_ = repeated_music_l ()->unfold_b_ ?
- repeated_music_l ()->repeats_i_ - 1 : 0;
-#endif
unfold_i_ = -1;
}
void
Repeated_music_iterator::construct_children ()
{
-#if 0
- unfold_i_ = repeated_music_l ()->unfold_b_ ?
- repeated_music_l ()->repeats_i_ - 1 : 0;
-#endif
- repeat_iter_p_ = get_iterator_p (repeated_music_l ()->repeat_p_);
+ repeat_iter_p_ = get_iterator_p (dynamic_cast<Repeated_music const*> (music_l_)->repeat_p_);
}
void
{
if (first_b_)
{
- bool success = report_to_l ()->try_music (repeated_music_l ());
+ bool success = report_to_l ()->try_music (dynamic_cast<Repeated_music const*> (music_l_));
if (!success)
music_l_->warning ( _("No one to print a volta bracket"));
}
Moment
Repeated_music_iterator::next_moment () const
{
+
if (repeat_iter_p_)
return repeat_iter_p_->next_moment () + here_mom_;
else if (alternative_iter_p_)
return alternative_iter_p_->next_moment () + here_mom_;
- // huh?
-// return repeated_music_l ()->repeat_p_->duration ()
-// * Moment (repeated_music_l ()->repeats_i_)
-// + repeated_music_l ()->alternative_p_->duration () + here_mom_;
- return repeated_music_l ()->alternative_p_->duration () + here_mom_;
+
+ Repeated_music const*r = dynamic_cast<Repeated_music const*>(music_l_);
+ return r->alternative_p_->length_mom () + here_mom_;
}
+/*
+ FIXME
+ */
bool
Repeated_music_iterator::ok () const
{
return ok ();
}
-Repeated_music*
-Repeated_music_iterator::repeated_music_l () const
-{
- return (Repeated_music*)Music_iterator::music_l_;
-}
void
Repeated_music_iterator::start_next_element ()
{
- if (repeat_iter_p_)
+ Repeated_music const*rep =dynamic_cast<Repeated_music const*> (music_l_);
+
+
+ if (repeat_iter_p_)
{
assert (!repeat_iter_p_->ok ());
assert (!alternative_iter_p_);
delete repeat_iter_p_;
repeat_iter_p_ = 0;
alternative_iter_p_ = dynamic_cast<Music_list_iterator*>
- (get_iterator_p ((Music*)repeated_music_l ()->alternative_p_));
- here_mom_ += repeated_music_l ()->repeat_p_->duration ();
+ (get_iterator_p ((Music*)rep->alternative_p_));
+ here_mom_ += rep->repeat_p_->length_mom ();
}
else if (alternative_iter_p_)
{
delete alternative_iter_p_;
alternative_iter_p_ = 0;
if (unfold_i_ < 0)
- unfold_i_ = repeated_music_l ()->unfold_b_ ?
- repeated_music_l ()->repeats_i_ - 1 : 0;
+ unfold_i_ = rep->unfold_b_ ?
+ rep->repeats_i_ - 1 : 0;
if (unfold_i_)
{
unfold_i_--;
- repeat_iter_p_ = get_iterator_p (repeated_music_l ()->repeat_p_);
+ repeat_iter_p_ = get_iterator_p (rep->repeat_p_);
// urg, assume same length alternatives for now...
-// here_mom_ += repeated_music_l ()->alternative_p_->music_p_list_p_->top ()->duration ();
+// here_mom_ += rep->alternative_p_->music_p_list_p_->top ()->length_mom ();
/*
URG
this is *wrong* but at least it doesn't dump core
how to intercept this...
*/
- here_mom_ += repeated_music_l ()->alternative_p_->duration ();
+ here_mom_ += rep->alternative_p_->length_mom ();
}
}
}
Repeated_music::Repeated_music (Repeated_music const& s)
: Music (s)
{
+ repeats_i_ = s.repeats_i_;
repeat_p_ = (s.repeat_p_) ? s.repeat_p_->clone () : 0;
// urg?
alternative_p_ = (s.alternative_p_) ? dynamic_cast <Music_sequence*> (s.alternative_p_->clone ()) : 0;
}
Moment
-Repeated_music::duration () const
+Repeated_music::length_mom () const
{
Moment m;
if (repeat_p_)
- m += repeat_p_->duration ();
+ m += repeat_p_->length_mom ();
if (alternative_p_)
- m += alternative_p_->duration ();
+ m += alternative_p_->length_mom ();
return m;
}
void
Request_chord_iterator::construct_children()
{
- elt_duration_ =elt_l ()->duration ();
+ elt_length_mom_ =elt_l ()->length_mom ();
get_req_translator_l();
}
bool
Request_chord_iterator::ok() const
{
- return (elt_duration_ && !last_b_) || first_b_;
+ return (elt_length_mom_ && !last_b_) || first_b_;
}
{
Moment m (0);
if (!first_b_)
- m = elt_duration_;
+ m = elt_length_mom_;
return m;
}
Request_chord_iterator::do_print() const
{
#ifndef NPRINT
- DOUT << "duration: " << elt_duration_;
+ DOUT << "duration: " << elt_length_mom_;
#endif
}
first_b_ = false;
}
- if (mom >= elt_duration_)
+ if (mom >= elt_length_mom_)
last_b_ = true;
}
bool streepjes_b = abs(position_i_) > staff_size_i_ /2 &&
(balltype_i_ == 0 || balltype_i_ == 1);
- Atom s(lookup_l ()->rest (balltype_i_, streepjes_b));
- Molecule * m = new Molecule ( Atom (s));
+ Molecule s(lookup_l ()->rest (balltype_i_, streepjes_b));
+ Molecule * m = new Molecule ( Molecule (s));
m->translate_axis (position_i_ * paper ()->internote_f (), Y_AXIS);
return m;
}
Item * item = dynamic_cast <Item *> (i.elem_l_);
if (!item)
return;
- if (dynamic_cast<Script *> (item)
- && i.req_l_
- && dynamic_cast <Musical_req *> (i.req_l_))
+ if (Script *s=dynamic_cast<Script *> (item))
{
- script_l_arr_.push ((Script*)item);
+ if (i.req_l_ && dynamic_cast <Musical_req *> (i.req_l_))
+ {
+ script_l_arr_.push (s);
+ }
}
- else if (dynamic_cast<Stem *> (item))
+ else if (Stem*s=dynamic_cast<Stem *> (item))
{
- stem_l_ = (Stem*) item;
+ stem_l_ = s;
}
- else if (dynamic_cast<Rhythmic_head *> (item))
+ else if (Rhythmic_head*r=dynamic_cast<Rhythmic_head *> (item))
{
- rhead_l_arr_.push ((Rhythmic_head*)item);
+ rhead_l_arr_.push (r);
}
- else if (dynamic_cast<Dot_column *> (item))
+ else if (Dot_column*d =dynamic_cast<Dot_column *> (item))
{
- dotcol_l_ = (Dot_column*) item;
+ dotcol_l_ = d;
}
}
--- /dev/null
+/*
+ rhythmic-grouping.cc -- implement Rhythmic_grouping
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+*/
+
+#include "debug.hh"
+#include "rhythmic-grouping.hh"
+#include "interval.hh"
+
+void
+Rhythmic_grouping::init()
+{
+ interval_ = 0;
+ children.clear();
+}
+
+void
+Rhythmic_grouping::OK() const
+{
+#ifndef NDEBUG
+ assert (bool (children.size()) != bool (interval_));
+
+ for (int i= 0; i < children.size(); i++)
+ {
+ children[i]->OK();
+ if (i>0)
+ assert (children[i-1]->interval().right ==
+ children[i]->interval().left);
+ }
+#endif
+}
+
+Moment
+Rhythmic_grouping::length_mom () const
+{
+ return interval().length ();
+}
+
+MInterval
+Rhythmic_grouping::interval() const
+{
+ if (interval_)
+ return *interval_;
+ else
+ return
+ MInterval (children[0]->interval().left,
+ children.top()->interval ().right);
+}
+
+void
+Rhythmic_grouping::split (Rhythmic_grouping r)
+{
+ if (interval_)
+ return ;
+
+ r.intersect (interval());
+ split (r.intervals());
+
+ for (int i= 0; i < children.size(); i++)
+ {
+ if (!children[i]->interval_)
+ {
+ Rhythmic_grouping here (r);
+ children[i]->split (here);
+ }
+ }
+}
+
+
+Array<MInterval>
+Rhythmic_grouping::intervals()
+{
+ Array<MInterval> r;
+ if (interval_ || children.size() == 1)
+ {
+ MInterval i (interval());
+ MInterval r1(i), r2(i);
+ r1.right = r2.left = i.center();
+ r.push (r1); r.push (r2);
+ }
+ else
+ {
+ for (int i=0; i < children.size(); i++)
+ r.push (children[i]->interval());
+ }
+ return r;
+}
+
+void
+Rhythmic_grouping::intersect (MInterval t)
+{
+ if (interval_)
+ {
+ interval_->intersect (t);
+ return;
+ }
+
+ for (int i=0; i < children.size(); i++)
+ {
+ MInterval inter = intersection (t, children[i]->interval());
+ if (inter.empty_b() || inter.length () <= Moment (0))
+ {
+ delete children[i];
+ children[i] =0;
+ }
+ else
+ {
+ children[i]->intersect (t);
+ }
+ }
+ for (int i=0; i < children.size();)
+ {
+ if (!children[i])
+ children.del (i);
+ else
+ i++;
+ }
+
+}
+
+/**
+ Put our children in branches of #this#.
+ The min and max time intervals coincide with elements of #splitpoints#
+
+ I really should be documenting what is happening here, but I find
+ that difficult, since I don't really understand what's going on here.
+
+ */
+void
+Rhythmic_grouping::split (Array<MInterval> splitpoints)
+{
+ //check on splitpoints..
+ int j = 0, i = 0, starti = 0, startj = 0;
+
+ Link_array<Rhythmic_grouping> ch;
+ while (1)
+ {
+ if (i >= children.size() || j >= splitpoints.size ())
+ break;
+
+ assert (
+ children[starti]->interval().left== splitpoints[startj].left);
+ if (children[i]->interval().right < splitpoints[j].right)
+ {
+ i ++;
+ }
+ else if (children[i]->interval().right > splitpoints[j].right)
+ {
+ j ++;
+ }
+ else
+ {
+
+ if (i == starti)
+ {
+ ch.push (children[i]);
+ }
+ else
+ {
+ Link_array<Rhythmic_grouping> slice = children.slice (starti, i+1);
+ Rhythmic_grouping *newchild=new Rhythmic_grouping (slice);
+
+ ch.push (newchild);
+ }
+ i ++;
+ j++;
+ starti = i;
+ startj = j;
+
+
+ }
+ }
+ if (ch.size() != 1)
+ children = ch;
+}
+
+
+Rhythmic_grouping::Rhythmic_grouping (MInterval t, int n)
+{
+ init();
+ if (n == 1 || !n)
+ {
+ interval_ = new MInterval (t);
+ return;
+ }
+ Moment dt = t.length ()/Moment (n);
+ MInterval basic = MInterval (t.left, t.left+dt);
+ for (int i= 0; i < n; i++)
+ children.push (new Rhythmic_grouping (dt*Moment (i) + basic));
+}
+
+
+Rhythmic_grouping::Rhythmic_grouping (Link_array<Rhythmic_grouping> r)
+ :children (r)
+{
+ interval_ =0;
+}
+
+Rhythmic_grouping::~Rhythmic_grouping()
+{
+ junk();
+}
+
+void
+Rhythmic_grouping::copy (Rhythmic_grouping const&s)
+{
+ interval_ = (s.interval_)? new MInterval (*s.interval_) : 0;
+ for (int i=0; i < s.children.size(); i++)
+ children.push (new Rhythmic_grouping (*s.children[i]));
+}
+
+void
+Rhythmic_grouping::operator=(Rhythmic_grouping const &s)
+{
+ junk();
+ copy (s);
+}
+
+Rhythmic_grouping::Rhythmic_grouping (Rhythmic_grouping const&s)
+{
+ init();
+ copy (s);
+}
+
+void
+Rhythmic_grouping::junk()
+{
+ delete interval_;
+ for (int i=0; i < children.size(); i++)
+ delete children[i];
+ init();
+}
+
+void
+Rhythmic_grouping::print() const
+{
+#ifndef NPRINT
+ DOUT << "{ \n";
+ if (interval_)
+ DOUT <<" Interval "<< interval_->str();
+ for (int i=0; i < children.size(); i++)
+ {
+ children[i]->print();
+ }
+ DOUT << "}\n";
+#endif
+}
+
+bool
+Rhythmic_grouping::child_fit_b (Moment start)
+{
+ if (children.size())
+ return (children.top()->interval ().right== start);
+
+ return true;
+}
+
+void
+Rhythmic_grouping::add_child (Moment start, Moment len)
+{
+ Moment stop = start+len;
+ assert (child_fit_b (start));
+ children.push (new Rhythmic_grouping (MInterval (start, stop)));
+}
+
+Rhythmic_grouping::Rhythmic_grouping()
+{
+ interval_ =0;
+}
+
+int
+min_elt (Array<int> v)
+{
+ int i = 1000; // ugh
+ for (int j = 0 ; j < v.size(); j++)
+ i = i <? v[j];
+ return i;
+}
+
+Array<int>
+Rhythmic_grouping::generate_beams (Array<int> flags, int &flagidx)
+{
+ assert (!interval_) ;
+
+ Array< Array<int> > children_beams;
+ for (int i=0; i < children.size(); i++)
+ {
+ Array<int> child_beams;
+ if (children[i]->interval_)
+ {
+ int f = flags[flagidx++];
+ child_beams.push (f);
+ }
+ else
+ {
+ child_beams = children[i]->
+ generate_beams (flags, flagidx);
+ }
+ children_beams.push (child_beams);
+ }
+ Array<int> beams;
+ int lastm, m, nextm;
+ for (int i=0; i < children_beams.size(); i++)
+ {
+ bool add_left = (i >0);
+ bool add_right = (i < children_beams.size() -1);
+
+ if (!i)
+ m = min_elt (children_beams[i]);
+ if (add_right)
+ nextm = min_elt (children_beams[i+1]);
+
+ if (children_beams[i].size() == 1)
+ {
+ if (add_right)
+ beams.push (m);
+ if (add_left)
+ beams.push (m);
+ }
+ else
+ {
+ if (add_left)
+ beams.push (lastm <? m);
+ beams.concat (children_beams[i]);
+ if (add_right)
+ beams.push (m <? nextm);
+ }
+ lastm = m;
+ m = nextm;
+ }
+ assert (!(beams.size()%2));
+ return beams;
+}
+
+void
+Rhythmic_grouping::translate (Moment m)
+{
+ if (interval_)
+ *interval_ += m;
+ else
+ for (int i=0; i < children.size(); i++)
+ children[i]->translate (m);
+}
+
+void
+Rhythmic_grouping::extend (MInterval m) const
+{
+ assert (m.left >= interval().left);
+ while (m.right >interval().right)
+ {
+ Link_array<Rhythmic_grouping> a (children);
+ for (int i=0; i < a.size(); i++)
+ {
+ a[i] =new Rhythmic_grouping (*children[i]);
+ a[i]->translate (children.top()->interval ().right);
+ }
+ ((Rhythmic_grouping*)this)->children.concat (a);
+ }
+ assert (m.right <= interval().right);
+ OK();
+}
+
+Rhythmic_grouping
+parse_grouping (Array<int> beat_i_arr, Array<Moment> elt_length_arr)
+{
+ Moment here =0;
+ assert (beat_i_arr.size() == elt_length_arr.size ());
+
+ Link_array<Rhythmic_grouping> children;
+ for (int i=0; i < beat_i_arr.size(); i++)
+ {
+ Moment last = here;
+ here += elt_length_arr[i] * Moment (beat_i_arr[i]);
+ children.push (
+ new Rhythmic_grouping (MInterval (last, here),
+ beat_i_arr[i]));
+ }
+ return Rhythmic_grouping (children);
+}
+
Score_element*
Score_element::dependency (int i) const
{
- return (Score_element*) get_out_edge_arr ()[i];
+ return (Score_element*) (get_out_edge_arr ()[i]);
}
int
Score_element*
Score_element::dependent (int i) const
{
- return (Score_element*) get_in_edge_arr()[i];
+ return (Score_element *)( get_in_edge_arr()[i]);
}
int
delete output_p_;
output_p_ = do_brew_molecule_p ();
- for (PCursor<Atom*> i(output_p_->atoms_); i.ok(); i++)
- {
- i->origin_l_ = this;
- }
-
pscore_l_->outputter_l_->output_molecule (output_p_,
absolute_offset (),
classname(this));
Molecule*
Score_element::do_brew_molecule_p() const
{
- Atom a (lookup_l ()->fill (Box (Interval (0,0), Interval (0,0))));
+ Molecule a (lookup_l ()->fill (Box (Interval (0,0), Interval (0,0))));
return new Molecule (a);
}
{
if (Rhythmic_req *rq = dynamic_cast <Rhythmic_req *> (announce_info_arr_[i].req_l_))
{
- musical_column_l_->add_duration (rq->duration());
+ musical_column_l_->add_duration (rq->length_mom ());
}
}
Engraver_group_engraver::do_announces();
assert (dynamic_cast<Paper_def *> (output_def_l_));
assert (!daddy_trans_l_);
pscore_p_ = new Paper_score;
- pscore_p_->paper_l_ = (Paper_def*)output_def_l_;
+ pscore_p_->paper_l_ = dynamic_cast<Paper_def*>(output_def_l_);
}
void
Score_performer::play (Audio_element * p)
{
- if (dynamic_cast<Audio_item *> (p))
+ if (
Audio_item * i=dynamic_cast<Audio_item *> (p))
{
- audio_column_l_->add_audio_item ((Audio_item*)p);
+ audio_column_l_->add_audio_item (i);
}
- else if (dynamic_cast<Audio_staff *> (p))
+ else if (
Audio_staff*s=dynamic_cast<Audio_staff *> (p))
{
- performance_p_->add_staff ((Audio_staff*)p);
+ performance_p_->add_staff (s);
}
performance_p_->add_element (p);
}
Translator_group::do_add_processing ();
assert (dynamic_cast<Midi_def *> (output_def_l_));
performance_p_ = new Performance;
- performance_p_->midi_l_ = (Midi_def*) output_def_l_;
+ performance_p_->midi_l_ = dynamic_cast<Midi_def*>(output_def_l_);
}
return ;
}
*mlog << '\n' << _("Interpreting music...") << flush;
- trans_p->last_mom_ = music_p_->duration ();
+ trans_p->last_mom_ = music_p_->length_mom ();
Music_iterator * iter = Music_iterator::static_get_iterator_p (music_p_, trans_p);
#include "debug.hh"
#include "script-def.hh"
-#include "atom.hh"
+
#include "paper-def.hh"
#include "lookup.hh"
return inside_staff_b_;
}
-Atom
-Script_def::get_atom (Paper_def *p , Direction d) const
+Molecule
+Script_def::get_molecule (Paper_def *p , Direction d) const
{
String preidx_str ="";
if (invertsym_b_)
if (!script_p->specs_p_->inside_b())
script_p->add_support (s_l);
- if (dynamic_cast<Text_def *> (script_p->specs_p_)) // UGH
+ if (Text_def*td_l = dynamic_cast<Text_def *> (script_p->specs_p_)) // UGH
{
- Text_def * td_l = (Text_def*)script_p->specs_p_;
if (!td_l->style_str_.length_i ())
{
Scalar style = get_property ("textstyle", 0);
Interval
Script::do_width () const
{
- return specs_p_->get_atom (paper (), dir_).extent ().x ();
+ return specs_p_->get_molecule (paper (), dir_).extent ().x ();
}
void
Interval
Script::symbol_height () const
{
- return specs_p_->get_atom (paper (), dir_).extent ().y ();
+ return specs_p_->get_molecule (paper (), dir_).extent ().y ();
}
-Interval
-Script::symbol_width () const
-{
- return specs_p_->width (paper ());
-}
Molecule*
Script::do_brew_molecule_p () const
{
Real dx =0.;
- Molecule*mol_p = new Molecule (specs_p_->get_atom (paper (), dir_));
+ Molecule*mol_p = new Molecule (specs_p_->get_molecule (paper (), dir_));
/*
ugh, staccato dots are not centred between stafflines (how?)?
*/
{
delete iter_p_;
iter_p_ =0;
- Moment elt_time = cursor_p_->ptr()->duration ();
+ Moment elt_time = cursor_p_->ptr()->length_mom ();
here_mom_ += elt_time;
cursor_p_->next();
}
notes.push (info.o_ - left);
}
Encompass_info info (encompass_arr_[encompass_arr_.size () - 1], dir_);
+
// urg:
Slur* urg = (Slur*)this;
urg->interstaff_f_ = info.interstaff_f_;
+
d.y () += interstaff_f_;
// prebreak
-/*
- span-bar-grav.cc -- implement Span_bar_engraver
+#include "base-span-bar-engraver.hh"
- source file of the GNU LilyPond music typesetter
- (c) 1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-*/
-
-#include "span-bar.hh"
-#include "span-bar-engraver.hh"
-#include "vertical-align-spanner.hh"
-
-Span_bar_engraver::Span_bar_engraver()
-{
- spanbar_p_ =0;
- valign_l_ =0;
-}
-
-Span_bar*
-Span_bar_engraver::get_span_bar_p() const
-{
- return new Span_bar;
-}
-
-
-void
-Span_bar_engraver::do_creation_processing ()
-{
-}
-
-void
-Span_bar_engraver::do_removal_processing ()
+class Span_bar_engraver : public Base_span_bar_engraver
{
-}
-
-void
-Span_bar_engraver::acknowledge_element (Score_element_info i)
-{
- int depth = i.origin_grav_l_arr_.size();
- if (depth > 1
- && dynamic_cast<Bar *> (i.elem_l_))
- {
- bar_l_arr_.push (dynamic_cast<Bar *> (i.elem_l_));
-
- if (bar_l_arr_.size() >= 2 && !spanbar_p_)
- /*
- hmm, i do want a bracket with one staff some times, but not always
- if (bar_l_arr_.size() >= 1 && !spanbar_p_)
-
- --jcn
- */
+protected:
+ Span_bar *get_span_bar_p ();
+public:
+ Span_bar_engraver ();
+ VIRTUAL_COPY_CONS (Translator);
+};
- /*
- use a property? get_property ("singleStaffBracket", 0) ?
-
- --hwn
- */
- {
- spanbar_p_ = get_span_bar_p();
- announce_element (Score_element_info (spanbar_p_,0));
- spanbar_p_-> type_str_ = bar_l_arr_[0]->type_str_;
- }
- }
- else if (dynamic_cast<Vertical_align_spanner *> (i.elem_l_)
- && i.origin_grav_l_arr_.size() <= 2)
- {
- valign_l_ = dynamic_cast<Vertical_align_spanner *> (i.elem_l_);
- }
-}
-
-void
-Span_bar_engraver::do_pre_move_processing()
+Span_bar_engraver::Span_bar_engraver ()
{
- if (spanbar_p_)
- {
- for (int i=0; i < bar_l_arr_.size() ; i++)
- spanbar_p_->add_bar (bar_l_arr_[i]);
- spanbar_p_->set_align (valign_l_);
- typeset_element (spanbar_p_);
- spanbar_p_ =0;
- }
- bar_l_arr_.set_size (0);
+ use_priority_b_ = false;
}
-
-
ADD_THIS_TRANSLATOR(Span_bar_engraver);
#include "span-bar.hh"
#include "lookup.hh"
#include "dimensions.hh"
-#include "atom.hh"
+
#include "paper-def.hh"
#include "molecule.hh"
#include "align-element.hh"
Interval
Span_bar::do_width () const
{
+ if (no_width_b_)
+ {
+ return Interval (0,0);
+ }
+
Molecule m = lookup_l ()->bar (type_str_, 40 PT);
return m.extent (X_AXIS);
Bar::do_pre_processing ();
evaluate_empty ();
+ translate_axis (extra_x_off_, X_AXIS);
+
+ dim_cache_[Y_AXIS].set_empty (false); // a hack to make mark scripts work.
}
void
}
}
-Molecule
-Span_bar::get_bar_sym (Real dy) const
-{
- if (dy < paper ()->staffheight_f () / 2)
- return Atom ();
-
- return lookup_l ()->bar (type_str_, dy);
-}
-
-Molecule*
-Span_bar::do_brew_molecule_p () const
+Interval
+Span_bar::get_spanned_interval () const
{
Interval y_int;
for (int i=0; i < spanning_l_arr_.size (); i++)
y_int.unite (y + spanning_l_arr_[i]->extent(Y_AXIS));
}
+ return y_int;
+}
+
+Interval
+Span_bar::do_height () const
+{
+ return get_spanned_interval ();
+}
+
+Molecule*
+Span_bar::do_brew_molecule_p () const
+{
+ Interval iv (get_spanned_interval ());
+ Molecule*output = new Molecule (lookup_l ()->bar (type_str_, iv.length ()));
- Molecule*output = new Molecule (get_bar_sym (y_int.length ()));
- output->translate_axis (y_int.center (), Y_AXIS);
+ output->translate_axis (iv.center (), Y_AXIS);
return output;
}
Span_bar::Span_bar ()
{
type_str_ = "";
+ extra_x_off_ = 0.0;
+ no_width_b_ = false;
}
/*
- span-score-bar-grav.cc -- implement Span_score_bar_engraver,
+ span-score-bar-engraver.cc -- implement Span_score_bar_engraver,
Piano_bar_engraver and Staff_group_bar_engraver
source file of the GNU LilyPond music typesetter
(c) 1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "span-score-bar.hh"
-#include "piano-brace.hh"
-#include "staff-bracket.hh"
+#include "span-bar.hh"
#include "span-score-bar-engraver.hh"
#include "paper-def.hh"
-
Span_bar*
Span_score_bar_engraver::get_span_bar_p () const
{
- Span_bar*s = new Span_score_bar;
- s->break_priority_i_ = -4;
+ Span_bar*s = new Span_bar;
+ s->visibility_lambda_
+ = gh_eval_str ("spanbar_non_postbreak_visibility");
+ s->type_str_ = "scorebar";
return s;
}
-
-
-
+Span_score_bar_engraver::Span_score_bar_engraver ()
+{
+ use_priority_b_ = true;
+ break_priority_i_ = -4;
+}
Span_bar*
Piano_bar_engraver::get_span_bar_p () const
{
- Span_bar *s= new Piano_brace;
- s->break_priority_i_ = -4;
+ Span_bar *s= new Span_bar;
+ s->visibility_lambda_
+ = gh_eval_str ("spanbar_postbreak_only_visibility");
+ s->no_width_b_ =true;
+ s->type_str_ = "{";
return s;
}
Span_bar*
Staff_group_bar_engraver::get_span_bar_p () const
{
- Span_bar *s= new Staff_bracket;
- s->break_priority_i_ = -4;
+ Span_bar *s= new Span_bar;
+ s->visibility_lambda_
+ = gh_eval_str ("spanbar_postbreak_only_visibility");
+ s->no_width_b_ =true;
+ s->type_str_ = "[";
return s;
}
void
Staff_group_bar_engraver::acknowledge_element (Score_element_info i)
{
- Span_bar_engraver::acknowledge_element (i);
- if (dynamic_cast<Piano_brace *> (i.elem_l_))
+ Base_span_bar_engraver::acknowledge_element (i);
+ if (Span_bar * b = dynamic_cast<Span_bar *> (i.elem_l_))
{
- Span_bar* b = dynamic_cast <Span_bar *> (i.elem_l_);
- Piano_brace * piano_l = (Piano_brace*) b;
- piano_l->extra_move_left_f_ = paper ()->interline_f (); // ugh
+ if (b->type_str_ == "{")
+ b->extra_x_off_ -= paper ()->interline_f (); // ugh
}
}
Score_column*
Spring_spacer::scol_l (int i)
{
- return (Score_column*)cols_[i].pcol_l_;
+ return dynamic_cast<Score_column*>(cols_[i].pcol_l_);
}
const Real COLFUDGE=1e-3;
Line_of_cols
Spring_spacer::error_pcol_l_arr() const
{
- Array<Paper_column*> retval;
+ Link_array<Paper_column> retval;
for (int i=0; i< cols_.size(); i++)
if (cols_[i].ugh_b_)
retval.push (cols_[i].pcol_l_);
if (delta_t)
{
Real k= paper_l()->arithmetic_constant (context_shortest_arr[i]);
- durational_distance = paper_l()->duration_to_dist (delta_t,k);
+ durational_distance = paper_l()->length_mom_to_dist (delta_t,k);
}
symbol_distance += -cols_[i+1].width_[LEFT];
}
Moment delta_t = scol_l (i+1)->when() - scol_l (i)->when ();
Real k= paper_l()->arithmetic_constant(context_shortest);
- Real dist = paper_l()->duration_to_dist (shortest_playing_len, k);
+ Real dist = paper_l()->length_mom_to_dist (shortest_playing_len, k);
dist *= (double)(delta_t / shortest_playing_len);
/*
*/
if (i + 1 < cols_.size () && scol_l(i+1)->breakable_b_)
{
- // one interline minimum seems ok for last column too?
- dist = dist >? interline_f;
+ // two interline minimum ok for last column?
+ dist = dist >? 2 * interline_f;
// set minimum rod
/*
-- jcn
*/
- cols_[i].width_[RIGHT] = cols_[i].width_[RIGHT] >? interline_f;
+ cols_[i].width_[RIGHT] = cols_[i].width_[RIGHT] >? 2 * interline_f;
}
// ugh, do we need this?
axis_ = X_AXIS;
type_ = "margin";
visibility_lambda_
- = gh_eval_str ("(lambda (d) (if (= d 1) '(#f . #f) '(#t . #t)))");
+ = gh_eval_str ("postbreak_only_visibility");
}
String long_str = get_property ("instrument", 0);
String str = get_property ("instr", 0);
- if (now_moment () > Moment (0) && str.length_i ())
+ if (now_mom () > Moment (0) && str.length_i ())
long_str = str;
if (long_str.empty_b ())
void
Staff_performer::play (Audio_element* p)
{
- if (dynamic_cast<Audio_item *> (p))
+ if (
Audio_item *ai = dynamic_cast<Audio_item *> (p))
{
- audio_staff_p_->add_audio_item ( (Audio_item*)p);
+ audio_staff_p_->add_audio_item (ai);
}
Performer::play (p);
}
if (!(abs (coordinate_offset_f_i) % 2))
y += (Real)dir_ * inter_f;
}
-// else
-// y = v[dir_] + 1 * dir_ * inter_f;
return y;
}
return Interval (0,0);
}
-Interval
-Staff_side::symbol_width () const
-{
- return Interval (0,0);
-}
-
void
Staff_side::do_pre_processing ()
{
if (axis_ == Y_AXIS)
return symbol_height ();
else
- return symbol_width ();
+ {
+ assert (false);
+ }
}
Staff_symbol::do_brew_molecule_p() const
{
Real w = extent (X_AXIS).length ();
- Real left_dx = -spanned_drul_[LEFT]->extent (X_AXIS)[LEFT];
- Real right_dx = spanned_drul_[RIGHT]->extent (X_AXIS)[RIGHT];
-
Paper_def * p = paper();
- Atom rule = lookup_l ()->rule_symbol (p->get_var ("rulethickness"),
- w);
+ Molecule rule = lookup_l ()->rule_symbol (p->get_var ("rulethickness"),
+ w);
Real height = (no_lines_i_-1) * inter_note_f();
Molecule * m = new Molecule;
for (int i=0; i < no_lines_i_; i++)
{
- Atom a (rule);
+ Molecule a (rule);
a.translate_axis (height - i * inter_note_f()*2, Y_AXIS);
m->add_molecule (a);
}
- // m->translate_axis (-left_dx, X_AXIS);
return m;
}
#include "proto.hh"
#include "misc.hh"
#include "debug.hh"
-#include "atom.hh"
+
#include "stem.hh"
#include "paper-def.hh"
#include "lookup.hh"
Stem::add_head (Rhythmic_head *n)
{
n->add_dependency (this); // ?
- if (dynamic_cast<Note_head *> (n))
+ if (Note_head *nh = dynamic_cast<Note_head *> (n))
{
- head_l_arr_.push ((Note_head*)n);
+ head_l_arr_.push (nh);
}
- else if (dynamic_cast<Rest *> (n))
+ else if (Rest *r = dynamic_cast<Rest *> (n))
{
- rest_l_arr_.push ((Rest*)n);
+ rest_l_arr_.push (r);
}
}
if (!invisible_b ())
{
- Atom ss =lookup_l ()->stem (stem_y[DOWN]*dy,
+ Molecule ss =lookup_l ()->stem (stem_y[DOWN]*dy,
stem_y[UP]*dy);
- mol_p->add_atom (ss);
+ mol_p->add_molecule (ss);
}
if (!beam_l_ && abs (flag_i_) > 2)
{
- Atom fl = lookup_l ()->flag (flag_i_, dir_);
+ Molecule fl = lookup_l ()->flag (flag_i_, dir_);
fl.translate_axis(stem_y[dir_]*dy, Y_AXIS);
- mol_p->add_atom (fl);
+ mol_p->add_molecule (fl);
}
if (head_l_arr_.size())
(c) 1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-
+#if 0
#ifndef __CYGWIN32__
#include "proto.hh"
#include "pcursor.hh"
#include "plist.tcc"
#endif
+#endif
return DOWN;
}
-Real
-Text_def::guess_width_f(Atom& a) const
-{
- return a.dim_.x ().length ();
-}
-
-Interval
-Text_def::width (Paper_def * p) const
-{
- Atom a = get_atom (p,CENTER);
-
- Interval i (0, guess_width_f (a));
- i += - (align_dir_ + 1)* i.center ();
- return i;
-}
void
Text_def::do_print() const
&& style_str_ == def->style_str_;
}
-Atom
-Text_def::get_atom (Paper_def *p, Direction) const
+Molecule
+Text_def::get_molecule (Paper_def *p, Direction) const
{
- Atom a= p->lookup_l(0)->text (style_str_, text_str_);
+ Molecule a= p->lookup_l(0)->text (style_str_, text_str_);
- a.translate_axis (-(align_dir_ + 1)* guess_width_f (a) / 2, X_AXIS);
+ a.translate_axis (-(align_dir_ + 1)* a.dim_[X_AXIS].center (), X_AXIS);
return a;
}
G_staff_side_item *ss = new G_staff_side_item;
ss->set_victim (text);
ss->dir_ = r->dir_;
-
+ Scalar p (get_property ("textstyle", 0)); // textStyle?
+ if (p.length_i ())
+ text->style_str_ = p;
text->text_str_ = t->text_str_;
announce_element (Score_element_info (text, r));
#include "text-def.hh"
#include "debug.hh"
#include "paper-def.hh"
-#include "atom.hh"
+
void
Molecule*
Text_spanner::do_brew_molecule_p() const
{
- Atom tsym (spec_p_->get_atom (paper(),CENTER));
+ Molecule tsym (spec_p_->get_molecule (paper(),CENTER));
tsym.translate (text_off_);
Molecule*output = new Molecule;
- output->add_atom (tsym);
+ output->add_molecule (tsym);
return output;
}
if (Note_head *nh = dynamic_cast<Note_head *> (i.elem_l_))
{
Note_req * m = dynamic_cast<Note_req* > (i.req_l_);
- now_heads_.push (CHead_melodic_tuple (nh, m, now_moment()+ m->duration ()));
+ now_heads_.push (CHead_melodic_tuple (nh, m, now_mom()+ m->length_mom ()));
}
}
{
if (req_l_)
{
- Moment now = now_moment ();
+ Moment now = now_mom ();
Link_array<Note_head> nharr;
stopped_heads_.clear ();
Tie_engraver::do_post_move_processing ()
{
req_l_ =0;
- Moment now = now_moment ();
+ Moment now = now_mom ();
while (past_notes_pq_.size () && past_notes_pq_.front ().end_ < now)
past_notes_pq_.delmin ();
}
s += "at ";
s += when_.str ();
s +="\ntime_signature " + (whole_per_measure_/one_beat_).str () +":" +
- (Rational (Rational (1)/one_beat_)).str ();
+ (Moment (Moment (1)/one_beat_)).str ();
s += "\nposition " + to_str (bars_i_) + ":"+ whole_in_measure_.str () +"\n}\n";
return s;
}
void
Time_description::add (Moment dt)
{
- assert (dt >= Rational (0));
+ assert (dt >= Moment (0));
when_ += dt;
whole_in_measure_ += dt;
Time_description::set_time_signature (int l, int o)
{
assert (o);
- one_beat_ = Rational (1)/Moment (o);
+ one_beat_ = Moment (1)/Moment (o);
whole_per_measure_ = Moment (l) * one_beat_;
}
String
Time_description::try_set_partial_str (Moment p) const
{
- if (p<Rational (0))
+ if (p<Moment (0))
return (_ ("partial measure must be non-negative"));
if (p > whole_per_measure_)
return (_ ("partial measure too large"));
Molecule*
Time_signature::do_brew_molecule_p () const
{
- Atom s;
if (time_sig_type_str_.length_i ())
{
if (time_sig_type_str_[0]=='1')
{
Array<int> tmparr = args_;
- tmparr[1]= 0;
- s = lookup_l ()->time_signature (tmparr);
+ return new Molecule( lookup_l ()->time_signature (args_[0], 0));
}
else
{
- s = lookup_l ()-> special_time_signature (time_sig_type_str_ ,args_);
+ return new Molecule( lookup_l ()-> special_time_signature (time_sig_type_str_ ,args_[0], args_[1]));
}
}
else
- s = lookup_l ()->time_signature (args_);
- s.translate_axis (-s.extent ()[Y_AXIS].center (), Y_AXIS);
- return new Molecule (Atom (s));
+ return new Molecule(lookup_l ()->time_signature (args_[0], args_[1]));
}
}
else if (Partial_measure_req *pm = dynamic_cast <Partial_measure_req *> (tr_l))
{
- Moment m = pm->duration_;
+ Moment m = pm->length_mom_;
String error = time_.try_set_partial_str (m);
if (error.length_i ())
{
void
Timing_translator::do_creation_processing()
{
- time_.when_ = now_moment ();
+ time_.when_ = now_mom ();
}
void
Timing_translator::do_post_move_processing()
{
- time_.add (now_moment () - time_.when_);
+ time_.add (now_mom () - time_.when_);
}
void
return 0;
}
-Array<Translator_ctor> *ctor_global_static_arr_p_;
-
-
-/*
- Very special greetings go out to Steve Jobs for creating a system
- that doesn't handle global construction correctly.
- */
-void
-add_constructor (Translator_ctor c)
-{
- if (!ctor_global_static_arr_p_)
- ctor_global_static_arr_p_ = new Array<Translator_ctor>;
- ctor_global_static_arr_p_->push (c);
-}
-
-void
-call_constructors ()
-{
- for (int i=0; i < ctor_global_static_arr_p_->size (); i++)
- add_translator (ctor_global_static_arr_p_->elem (i) ());
-}
void
Translator_group::terminate_translator (Translator*r_l)
{
- DOUT << "Removing " << classname (r_l) << " at " << now_moment () << '\n';
+ DOUT << "Removing " << classname (r_l) << " at " << now_mom () << '\n';
r_l->removal_processing();
Translator * trans_p =remove_translator_p (r_l);
Moment
-Translator::now_moment () const
+Translator::now_mom () const
{
- return daddy_trans_l_->now_moment ();
+ return daddy_trans_l_->now_mom ();
}
if (!dynamic_cast<Request_chord*> (el))
{
compressed_music_arr_.push (c);
- stop_moments_.push (now_moment () + c->duration ());
+ stop_moments_.push (now_mom () + c->length_mom ());
}
return true;
}
void
Tuplet_engraver::do_post_move_processing ()
{
- Moment now = now_moment ();
+ Moment now = now_mom ();
for (int i= started_span_p_arr_.size (); i--; )
{
if (now >= stop_moments_[i])
todo: handle breaking elegantly.
*/
#include "beam.hh"
-#include "atom.hh"
+
#include "box.hh"
#include "debug.hh"
#include "lookup.hh"
if (column_arr_.size ()){
Real ncw = column_arr_.top ()->extent (X_AXIS).length ();
- Atom num (tdef_p_->get_atom (paper (), CENTER));
+ Molecule num (tdef_p_->get_molecule (paper (), CENTER));
if (beam_l_ && !bracket_visibility_b_)
{
- num.translate (((Directional_spanner*)beam_l_)->center ());
+ Directional_spanner* ds = dynamic_cast<Directional_spanner*>(beam_l_);
+ num.translate (ds->center ());
num.translate_axis (ncw, X_AXIS);
}
Real w = extent (X_AXIS).length () + ncw;
num.translate (Offset (w/2, dy/2));
- mol_p->add_atom (lookup_l ()->plet (dy, w, dir_));
+ mol_p->add_molecule (lookup_l ()->plet (dy, w, dir_));
}
if (num_visibility_b_)
- mol_p->add_atom (num);
+ mol_p->add_molecule (num);
}
return mol_p;
}
(c) 1997--1998 Jan Nieuwenhuizen <janneke@gnu.org>
*/
-#include "atom.hh"
+
#include "box.hh"
#include "debug.hh"
#include "lookup.hh"
template class P<Text_def>; // UGH
-
Volta_spanner::Volta_spanner ()
{
last_b_ = false;
Real internote_f = paper ()->internote_f ();
Real dx = internote_f;
Real w = extent (X_AXIS).length () - dx;
- Atom volta (lookup_l ()->volta (w, last_b_));
+ Molecule volta (lookup_l ()->volta (w, last_b_));
Real h = volta.dim_.y ().length ();
- Atom num (number_p_->get_atom (paper (), LEFT));
+ Molecule num (number_p_->get_molecule (paper (), LEFT));
Real dy = column_arr_.top ()->extent (Y_AXIS) [UP] >
column_arr_[0]->extent (Y_AXIS) [UP];
dy += 2 * h;
dy = dy >? note_column_arr_[i]->extent (Y_AXIS).max ();
dy -= h;
- Real gap = num.dim_.x ().length () / 2;
+ Text_def two_text;
+ two_text.text_str_ = "2";
+ two_text.style_str_ = number_p_->style_str_;
+ Molecule two (two_text.get_molecule (paper (), LEFT));
+ Real gap = two.dim_.x ().length () / 2;
Offset off (num.dim_.x ().length () + gap,
h / internote_f - gap);
num.translate (off);
- mol_p->add_atom (volta);
- mol_p->add_atom (num);
+ mol_p->add_molecule (volta);
+ mol_p->add_molecule (num);
mol_p->translate (Offset (0, dy));
return mol_p;
}
set_bounds (RIGHT, column_arr_.top ());
}
- number_p_->style_str_ = "number-1";
+ number_p_->style_str_ = "number"; // number-1
}
Interval
--- /dev/null
+%
+% setup for auto beamer
+%
+time2_8beamAutoEnd = "2/8";
+time3_2beamAutoEnd = "1/2";
+time3_2beamAutoEnd16 = "1/4";
+time3_2beamAutoEnd32 = "1/8";
+time3_4beamAutoBegin = "1/4";
+time3_4beamAutoEnd8 = "3/4";
+time3_4beamAutoEnd32 = "1/8";
+time3_8beamAutoBegin = "1/8";
+time3_8beamAutoEnd = "3/8";
+time4_4beamAutoEnd8 = "1/2";
+time4_4beamAutoEnd32 = "1/8";
+time4_8beamAutoEnd8 = "1/4";
+time4_8beamAutoEnd16 = "1/4";
+time4_8beamAutoEnd32 = "1/8";
+time4_16beamAutoEnd = "1/8";
+time6_8beamAutoEnd8 = "3/8";
+time6_8beamAutoEnd16 = "3/8";
+time6_8beamAutoEnd32 = "1/8";
+time9_8beamAutoEnd8 = "3/8";
+time9_8beamAutoEnd16 = "3/8";
+time6_8beamAutoEnd32 = "1/8";
\include "property.ly"
-\scmfile "lily.scm";
+
unusedEntry = \notes { c4 } % reset default duration
% declare the standard dynamic identifiers.
%
-pppppp = \absdynamic { 13 }
-ppppp = \absdynamic { 12 }
-pppp = \absdynamic { 11 }
-ppp = \absdynamic { 10 }
-pp = \absdynamic { 9 }
-p = \absdynamic { 8 }
-mp = \absdynamic { 7 }
-mf = \absdynamic { 6 }
-f = \absdynamic { 5 } % f is a notename too.
-ff = \absdynamic { 4 }
-fff = \absdynamic { 3 }
-ffff = \absdynamic { 2 }
-fffff = \absdynamic { 1 }
-ffffff = \absdynamic { 0 }
+pppppp = \absdynamic { "pppppp" } % Yeah yeah, \absdynamic "foo"; would/should also work.
-fp = \absdynamic { 14 }
-sf = \absdynamic { 15 }
-sff = \absdynamic { 16 }
-sfz = \absdynamic { 17 }
-sp = \absdynamic { 18 }
-spp = \absdynamic { 19 }
-rfz = \absdynamic { 20 }
+ppppp = \absdynamic { "ppppp" }
+pppp = \absdynamic { "pppp" }
+ppp = \absdynamic { "ppp" }
+pp = \absdynamic { "pp" }
+p = \absdynamic { "p" }
+mp = \absdynamic { "mp" }
+mf = \absdynamic { "mf" }
+f = \absdynamic { "f" }
+ff = \absdynamic { "ff" }
+fff = \absdynamic { "fff" }
+ffff = \absdynamic { "ffff" }
+fffff = \absdynamic { "fffff" }
+ffffff = \absdynamic { "ffffff" }
+
+fp = \absdynamic { "fp" }
+sf = \absdynamic { "sf" }
+sff = \absdynamic { "sff" }
+sfz = \absdynamic { "sfz" }
+sp = \absdynamic { "sp" }
+spp = \absdynamic { "spp" }
+rfz = \absdynamic { "rfz" }
cr = \spandynamic { 1 1 }
decr = \spandynamic { -1 1 }
tuplet_thick = 1.0*\staffline;
volta_thick = 1.6*\staffline;
+extender_height = 0.8*\staffline;
+
\include "engraver.ly";
[Staff]
barAuto 0 none
barAuto 1 auto-generate bar every measure
+barAtLineStart 0/1 generate bar at beginning of line
[Staff]
beamAuto 0/1 auto-beam on/off
n/m=2/2,3/2,3/4,4/4,6/4 or 9/4.
[Staff]
voltaVisibility 0/1 on/off
+voltaSpannerDuration Rat. Coda kludge: set length of volta-spanner,
+ typically set to one measure: "1"
[Staff?]
instrument ascii midi instrument table lookup
EXTRA_DIST_FILES += TODO README feta.mp mfplain.ini
-FET_FILES = $(wildcard feta[0-9]*.mf) feta-din10.mf \
- $(wildcard feta-nummer[0-9]*.mf)
+FET_FILES = $(wildcard feta[0-9]*.mf)
LYTABLES = $(addprefix $(outdir)/, $(FET_FILES:.mf=.ly))
LOG_FILES = $(addprefix $(outdir)/, $(FET_FILES:.mf=.log))
% -*- Fundamental -*-
+
+
accreg_dot_size# := .7interline#;
accreg_linethickness# := 1.3stafflinethickness#;
-%
+% -*-Fundamental-*-
% feta-bolletjes.mf -- implement noteheads
%
% source file of LilyPond's pretty-but-neat music font
save black_notehead_width;
numeric black_notehead_width;
-fet_begingroup("balls");
+fet_begingroup("noteheads");
noteheight#:=interline#+ (1 + overdone_heads) *stafflinethickness#;
define_pixels(noteheight);
draw z1 .. z2;
enddef;
+fet_beginchar("Ledger ending", "ledgerending", "ledgerending")
+set_char_box (5/2 ledgerlinethickness#, 5/2 ledgerlinethickness#,
+ ledgerlinethickness#/2,ledgerlinethickness#/2);
+ pickup pencircle scaled ledgerlinethickness;
+ lft x1 = -b;
+ rt x2 = w;
+ y1 =0; y2 =0;
+ draw z1 .. z2;
+fet_endchar;
+
fet_beginchar("Brevis notehead", "-1", "brevisball")
draw_brevis(brevis_wid#);
fet_endchar;
-fet_beginchar("Brevis ledger", "-1l", "brevisledger")
- draw_ledger(brevis_wid#);
-fet_endchar;
%
% Some sources (eg Musix/OpusTeX think that the appendage should be on
fill z7r .. z6r{z6-z7} .. {z7-z6} z6l -- z7l -- cycle;
penlabels(6,7);
fet_endchar;
-fet_beginchar("Longa ledger", "-2l", "longaledger")
- draw_ledger(brevis_wid#);
-fet_endchar;
% setup user vars
fet_endchar;
-fet_beginchar("Whole ledger line", "0l", "wholeledger")
- draw_ledger(whole_notehead_width#);
-fet_endchar;
% half note
% Wanske, p.39
fet_endchar;
-fet_beginchar("Half ledger", "1l", "halfledger")
- draw_ledger(half_notehead_width#);
-fet_endchar;
% quarter note
% Wanske p.38
fet_endchar;
-fet_beginchar("Quart ledger", "2l", "quartledger")
- draw_ledger(black_notehead_width#);
-fet_endchar;
draw_harmonic_notehead(harmonic_wid#)
fet_endchar;
-fet_beginchar("Harmonic ledger", "harmonicl", "harmonicledger")
- draw_ledger(harmonic_wid#);
-fet_endchar;
%fi
-fet_endgroup("balls");
+fet_endgroup("noteheads");
define_pixels(black_notehead_width);
\translator{ \OrchestralScoreContext }
\translator{
\VoiceContext
- \consists Auto_beam_engraver;
- beamAuto = 1.;
beamAutoEnd8 = "1/4";
beamAutoEnd16 = "1/4";
}
minVerticalAlign = 3.0*\staffheight;
maxVerticalAlign = 3.0*\staffheight;
}
- \translator{
- \VoiceContext
- \consists Auto_beam_engraver;
- beamAuto = "1";
- beamAutoEnd8 = "1/2";
- beamAutoEnd16 = "1/4";
- }
}
\midi{ \tempo 4 = 80; }
\header {
\paper{
\include "preludes-paper.ly";
gourlay_maxmeasures = 4.0;
- \translator{
- \VoiceContext
- \consists Auto_beam_engraver;
- beamAuto = "1";
- beamAutoEnd8 = "1/2";
- beamAutoEnd16 = "1/4";
- }
}
\midi{ \tempo 4 = 100; }
\header {
minVerticalAlign = 3.0*\staffheight;
maxVerticalAlign = 3.0*\staffheight;
}
- \translator{
- \VoiceContext
- \consists Auto_beam_engraver;
- beamAuto = "1";
- beamAutoEnd8 = "1/2";
- beamAutoEnd16 = "1/4";
- }
}
\midi{ \tempo 4 = 70; }
\header{
minVerticalAlign = 3.0*\staffheight;
maxVerticalAlign = 3.0*\staffheight;
}
- \translator{
- \VoiceContext
- \consists Auto_beam_engraver;
- beamAuto = "1";
- beamAutoEnd8 = "3/4";
- beamAutoEnd16 = "1/4";
- }
}
\midi{ \tempo 4 = 90; }
\header{
minVerticalAlign = 3.0*\staffheight;
maxVerticalAlign = 3.0*\staffheight;
}
- \translator{
- \VoiceContext
- \consists Auto_beam_engraver;
- beamAuto = "1";
- beamAutoEnd8 = "1/2";
- beamAutoEnd16 = "1/4";
- beamAutoEnd32 = "1/4";
- }
}
\midi{ \tempo 4 = 40; }
\header{
linewidth = 180.\mm;
gourlay_maxmeasures = 10.0;
\translator { \BarNumberingStaffContext }
-\translator {
- \VoiceContext
- \consists Auto_beam_engraver;
- beamAuto = 1.0;
- beamAutoEnd8 = "1/4";
- beamAutoEnd16 = "1/4";
- beamAutoEnd32 = "1/4";
-}
minVerticalAlign = 3.0*\staffheight;
maxVerticalAlign = 3.0*\staffheight;
}
- \translator {
- \VoiceContext
- \consists Auto_beam_engraver;
- beamAuto = 1.;
- % eights end at 1/2, 16 at 1/4
- beamAutoEnd = "1/2";
- }
}
\header{
opus = "BWV 847";
stroke
} bind def
-/draw_slur
+% this is for drawing slurs.
+/draw_bezier_sandwich
{
stafflinethickness setlinewidth
moveto
;
; (c) 1998 Jan Nieuwenhuizen <janneke@gnu.org>
-; TODO
-; - naming
-; - ready ps code (draw_bracket) vs tex/ps macros/calls (pianobrace),
-; all preparations from ps,tex to scm
+
+(debug-enable 'backtrace)
;;; library funtions
(define
(define security-paranoia #f)
-;;;;;;;;
-;;; UGH. THESE SUCK!
-
-(define (empty)
- "")
-
-(define (empty1 a)
- "")
-
-(define (empty2 a b )
- "")
-
-(define emptybar empty1)
-
-;;; and these suck as well.
-(define (setdynamic s) (text "dynamic" (string-append "\\" s)))
-(define (setroman s) (text "text" s))
-(define (settypewriter s) (text "typewriter" s))
-(define (setnumber s) (text "number" s))
-(define (setbold s) (text "bold" s))
-(define (setlarge s) (text "large" s))
-(define (setLarge s) (text "Large" s))
-(define (setmark s) (text "mark" s))
-(define (setfinger s) (text "finger" s))
-(define (setitalic s) (text "italic" s))
-(define (setnumber-1 s) (text "numberj" s))
-
+;; See documentation of Item::visibility_lambda_
+(define (postbreak_only_visibility d) (if (= d 1) '(#f . #f) '(#t . #t)))
+(define (non_postbreak_visibility d) (if (= d -1) '(#t . #t) '(#f . #f)))
+(define (spanbar_non_postbreak_visibility d) (if (= d -1) '(#t . #t) '(#f . #f)))
+(define (spanbar_postbreak_only_visibility d) (if (= d 1) '(#f . #f) '(#t . #t)))
;;;;;;;; TeX
(define (unknown)
"%\n\\unknown%\n")
+ (define font-alist '())
+ (define font-count 0)
+ (define current-font "")
+ (define (clear-fontcache)
+ (begin
+ (set! font-alist '())
+ (set! font-count 0)
+ (set! current-font "")))
+
+ (define (cached-fontname i)
+ (string-append
+ "\\lilyfont"
+ (make-string 1 (integer->char (+ 65 i)))
+ )
+ )
+
+ (define (select-font font-name)
+ (if (not (equal? font-name current-font))
+ (begin
+ (set! current-font font-name)
+ (define font-cmd (assoc font-name font-alist))
+ (if (eq? font-cmd #f)
+ (begin
+ (set! font-cmd (cached-fontname font-count))
+ (set! font-alist (acons font-name font-cmd font-alist))
+ (set! font-count (+ 1 font-count))
+ (string-append "\\font" font-cmd "=" font-name font-cmd)
+ )
+ (cdr font-cmd))
+ )
+
+ "" ;no switch needed
+
+ )
+
+ )
+
+
+
(define (beam width slope thick)
(embedded-ps ((ps-scm 'beam) width slope thick)))
(define (decrescendo w h cont)
(embedded-ps ((ps-scm 'decrescendo) w h cont)))
- (define
- (doublebar h)
- (invoke-dim1 "doublebar" h))
(define (embedded-ps s)
(string-append "\\embeddedps{" s "}"))
(define (experimental-on) "\\turnOnExperimentalFeatures")
- (define (extender h)
- (invoke-dim1 "extender" h))
- (define
- (fatdoublebar h)
- (invoke-dim1 "fatdoublebar" h))
- (define
- (finishbar h)
- (invoke-dim1 "finishbar" h))
+
(define (font-switch i)
(string-append
(string-append
"{\\bracefont " (char (/ (- (min y (- maxht step)) minht) step)) "}"))
- (define
- (repeatbar h)
- (invoke-dim1 "repeatbar" h))
- (define
- (repeatbarstartrepeat h)
- (invoke-dim1 "repeatbarstartrepeat" h))
(define (rulesym h w)
(string-append
)
)
- (define (slur l)
- (embedded-ps ((ps-scm 'slur) l)))
-
- (define
- (startbar h)
- (invoke-dim1 "startbar" h))
+ (define (bezier-sandwich l)
+ (embedded-ps ((ps-scm 'bezier-sandwich) l)))
- (define
- (startrepeat h)
- (invoke-dim1 "startrepeat" h))
- (define (start-line)
- (string-append
- "\\hbox{%\n")
+ (define (start-line)
+ (begin
+ (clear-fontcache)
+ "\\hbox{%\n")
)
- (define (filledbox breapth width height depth)
+ (define (filledbox breapth width depth height)
(string-append
"\\kern" (number->dim (- breapth))
"\\vrule width " (number->dim (+ breapth width))
(define (stop-line)
"}\\interscoreline")
- (define
- (stoprepeat h)
- (invoke-dim1 "stoprepeat" h))
- (define (text f s)
- (string-append "\\set" f "{" (output-tex-string s) "}"))
+ (define (text s)
+ (string-append "\\hbox{" (output-tex-string s) "}"))
(define (tuplet dx dy thick dir)
(embedded-ps ((ps-scm 'tuplet) dx dy thick dir)))
(define (volta w thick last)
(embedded-ps ((ps-scm 'volta) w thick last)))
- (define (maatstreep h)
- (string-append "\\maatstreep{" (number->dim h) "}"))
-
- ; urg: generate me
+
+ ;; The procedures listed below form the public interface of TeX-scm.
+ ;; (should merge the 2 lists)
(cond ((eq? action-name 'all-definitions)
`(begin
(define beam ,beam)
(define bracket ,bracket)
(define crescendo ,crescendo)
(define dashed-slur ,dashed-slur)
- (define doublebar ,doublebar)
- (define emptybar ,emptybar)
(define decrescendo ,decrescendo)
- (define empty ,empty)
(define end-output ,end-output)
- (define extender ,extender)
- (define fatdoublebar ,fatdoublebar)
- (define finishbar ,finishbar)
(define font-def ,font-def)
(define font-switch ,font-switch)
(define generalmeter ,generalmeter)
(define invoke-char ,invoke-char)
(define invoke-dim1 ,invoke-dim1)
(define placebox ,placebox)
- (define repeatbar ,repeatbar)
- (define repeatbarstartrepeat ,repeatbarstartrepeat)
(define rulesym ,rulesym)
- (define slur ,slur)
- (define startbar ,startbar)
- (define startrepeat ,startrepeat)
- (define stoprepeat ,stoprepeat)
+ (define bezier-sandwich ,bezier-sandwich)
+ (define select-font ,select-font)
(define start-line ,start-line)
(define filledbox ,filledbox)
(define stop-line ,stop-line)
(define text ,text)
(define experimental-on ,experimental-on)
(define char ,char)
- (define maatstreep ,maatstreep)
(define pianobrace ,pianobrace)
(define volta ,volta)
))
((eq? action-name 'bracket) bracket)
((eq? action-name 'crescendo) crescendo)
((eq? action-name 'dashed-slur) dashed-slur)
- ((eq? action-name 'doublebar) doublebar)
((eq? action-name 'decrescendo) decrescendo)
- ((eq? action-name 'empty) empty)
((eq? action-name 'end-output) end-output)
- ((eq? action-name 'extender) extender)
- ((eq? action-name 'fatdoublebar) fatdoublebar)
- ((eq? action-name 'finishbar) finishbar)
((eq? action-name 'font-def) font-def)
((eq? action-name 'font-switch) font-switch)
((eq? action-name 'generalmeter) generalmeter)
((eq? action-name 'invoke-char) invoke-char)
((eq? action-name 'invoke-dim1) invoke-dim1)
((eq? action-name 'placebox) placebox)
- ((eq? action-name 'repeatbar) repeatbar)
- ((eq? action-name 'repeatbarstartrepeat) repeatbarstartrepeat)
((eq? action-name 'rulesym) rulesym)
- ((eq? action-name 'slur) slur)
- ((eq? action-name 'startbar) startbar)
- ((eq? action-name 'startrepeat) startrepeat)
- ((eq? action-name 'stoprepeat) stoprepeat)
+ ((eq? action-name 'bezier-sandwich) bezier-sandwich)
((eq? action-name 'start-line) start-line)
((eq? action-name 'stem) stem)
((eq? action-name 'stop-line) stop-line)
(numbers->string (list w h (inexact->exact cont)))
"draw_decrescendo"))
- (define (empty)
- "\n empty\n")
(define (end-output)
"\nshowpage\n")
(number->string y) " "
"rulesym"))
- (define (slur l)
+ (define (bezier-sandwich l)
(string-append
(apply string-append (map control->string l))
- " draw_slur"))
-
- (define (start-line)
- "\nstart_line {\n")
+ " draw_bezier_sandwich"))
+ (define (start-line)
+ (begin
+ (clear-fontcache)
+ "\nstart_line {\n"))
+
(define (stem kern width height depth)
(string-append (numbers->string (list kern width height depth))
"draw_stem" ))
- (define (stop-line)
- "}\nstop_line\n")
+ (define (stop-line)
+ "}\nstop_line\n")
(define (text f s)
(string-append "(" s ") set" f " "))
(define bracket ,bracket)
(define crescendo ,crescendo)
(define volta ,volta)
- (define slur ,slur)
+ (define bezier-sandwich ,bezier-sandwich)
(define dashed-slur ,dashed-slur)
(define decrescendo ,decrescendo)
- (define empty ,empty)
+
(define end-output ,end-output)
(define font-def ,font-def)
(define font-switch ,font-switch)
((eq? action-name 'bracket) bracket)
((eq? action-name 'crescendo) crescendo)
((eq? action-name 'volta) volta)
- ((eq? action-name 'slur) slur)
+ ((eq? action-name 'bezier-sandwich) bezier-sandwich)
((eq? action-name 'dashed-slur) dashed-slur)
((eq? action-name 'decrescendo) decrescendo)
(else (error "unknown tag -- PS-SCM " action-name))
)
+;
+; Russ McManus, <mcmanus@IDT.NET>
+;
+; I use the following, which should definitely be provided somewhere
+; in guile, but isn't, AFAIK:
+;
+;
+(define (hash-table-for-each fn ht)
+ (do ((i 0 (+ 1 i)))
+ ((= i (vector-length ht)))
+ (do ((alist (vector-ref ht i) (cdr alist)))
+ ((null? alist) #t)
+ (fn (car (car alist)) (cdr (car alist))))))
+
+(define (hash-table-map fn ht)
+ (do ((i 0 (+ 1 i))
+ (ret-ls '()))
+ ((= i (vector-length ht)) (reverse ret-ls))
+ (do ((alist (vector-ref ht i) (cdr alist)))
+ ((null? alist) #t)
+ (set! ret-ls (cons (fn (car (car alist)) (cdr (car alist))) ret-ls)))))
% stacked horizontal lines
\def\interscoreline{\vskip 16pt}
-\def\setdynamic#1{\dynfont #1}
-\def\setfinger#1{\fingerfont #1}
-\def\setnumber#1{\fetanummer #1}
-\def\setnumberj#1{\fetanummerj #1}
-\def\setmark#1{\markfont #1}
% big fat marks, if errors are detected.
\def\columnerrormark{\placebox{-5pt}{0pt}{\bf C!}}
%{\bf u} %FIXME
}
-\input dyndefs
\input fetdefs
-\def\deprecated#1S{%%%%%%%%%
-
-\def\emptybar{}
-
-
-
-\def\defaultthinbar{\thinbar{\staffheight}}
-\def\defaultthickbar{\thickbar{\staffheight}}
-%? what-s wrong with rightalign?
-\def\repeatstopbar{\rightalign{\repeatcolon\kern2\smallspace\defaultthinbar\kern\smallspace\defaultthickbar}}
-\def\repeatstartbar{\hbox{\defaultthickbar\kern\smallspace\defaultthinbar\kern2\smallspace\repeatcolon}}
-\def\repeatstopstart{\hbox{\repeatcolon\kern2\smallspace\defaultthickbar\kern\smallspace\defaultthickbar\kern2\smallspace\repeatcolon}}
-
-%compatibility
-%urg
-\fetdef\repeatcolon{21}
-\def\repeatbar#1{\repeatstopbar}
-\def\startrepeat#1{\repeatstartbar}
-\def\repeatbarstartrepeat#1{\repeatstopstart}
-
-\def\doublebar#1{\hbox{\thinbar{#1}\hskip\smallspace\thinbar{#1}}}
-\def\thinbar#1{\dimen0=#1%
- \vrule height .5\dimen0 depth .5\dimen0 width 1.6\stafflinethickness} % TODO parametric.
-\def\thickbar#1{\dimen0=#1%
- \vrule height .5\dimen0 depth .5\dimen0 width 2\smallspace}
-\def\maatstreep#1{\thinbar{#1}}
-\def\startbar#1{\leftalign{\thickbar{#1}\kern\smallspace\thinbar{#1}}}
-\def\finishbar#1{\rightalign{\thinbar{#1}\kern\smallspace\thickbar{#1}}}
-\def\fatdoublebar#1{\hbox{\phantom{\repeatcolon\kern2\smallspace}\thickbar{#1}\kern\smallspace\thickbar{#1}}}
-}
-
-
-\def\extender#1{\vrule width#1 height .8\stafflinethickness}
-
% ugh
% see e.g. input/test/beam-pos.ly
%
projects / lilypond.git / commitdiff