@end ignore
+@item
+Slurs and phrasing slurs may now be started from individual notes
+in a chord. Several simultanous slurs per @code{Voice} need to be
+distinguished by @code{spanner-id} setting.
+
+@item
+The music and grob property @code{spanner-id} for distinguishing
+simultaneous slurs and phrasing slurs has been changed from a
+string to a @q{key}, a non-negative integer or symbol.
+
+@item
+There is a new command @code{\=} for specifying the
+@code{spanner-id} for simultaneous slurs and phrasing slurs.
+@lilypond[verbatim,quote]
+\fixed c' {
+ <c~ f\=1( g\=2( >2 <c e\=1) a\=2) >
+}
+@end lilypond
+
@item
Blocks introduced with @code{\header} can be stored in variables
and used as arguments to music and scheme functions and as the
@end example
-@subheading Indenting with vim
-
-Although emacs indentation is the GNU standard, acceptable
-indentation can usually be accomplished with vim. Some hints for
-vim are as follows:
-
-A workable .vimrc:
-
-@example
-set cindent
-set smartindent
-set autoindent
-set expandtab
-set softtabstop=2
-set shiftwidth=2
-filetype plugin indent on
-set incsearch
-set ignorecase smartcase
-set hlsearch
-set confirm
-set statusline=%F%m%r%h%w\ %@{&ff@}\ %Y\ [ASCII=\%03.3b]\ [HEX=\%02.2B]\ %04l,%04v\ %p%%\ [LEN=%L]
-set laststatus=2
-set number
-" Remove trailing whitespace on write
+@subsubheading Indenting with vim
+
+Although emacs indentation is the GNU standard, correct
+indentation for C++ files can be achieved by using the settings
+recommended in the
+@url{https://gcc.gnu.org/wiki/FormattingCodeForGCC, GNU GCC Wiki}.
+Save the following in @file{~/.vim/after/ftplugin/cpp.vim}:
+
+@example
+setlocal cindent
+setlocal cinoptions=>4,n-2,@{2,^-2,:2,=2,g0,h2,p5,t0,+2,(0,u0,w1,m1
+setlocal shiftwidth=2
+setlocal softtabstop=2
+setlocal textwidth=79
+setlocal fo-=ro fo+=cql
+" use spaces instead of tabs
+setlocal expandtab
+" remove trailing whitespace on write
autocmd BufWritePre * :%s/\s\+$//e
@end example
-With this @file{.vimrc}, files can be reindented automatically by
+With these settings, files can be reindented automatically by
highlighting the lines to be indented in visual mode (use V to
-enter visual mode) and pressing @code{=}.
+enter visual mode) and pressing @code{=}, or a single line
+correctly indented in normal mode by pressing @code{==}.
-A @file{scheme.vim} file will help improve the indentation. This
-one was suggested by Patrick McCarty. It should be saved in
-@file{~/.vim/after/syntax/scheme.vim}.
+A @file{scheme.vim} file will help improve the indentation of
+Scheme code. This one was suggested by Patrick McCarty. It
+should be saved in @file{~/.vim/after/syntax/scheme.vim}.
@example
" Additional Guile-specific 'forms'
syn keyword schemeSyntax def-grace-function
" All of the above should influence indenting too
-set lw+=define-public,define*-public
-set lw+=define*,lambda*,let-keywords*
-set lw+=defmacro,defmacro*,define-macro
-set lw+=defmacro-public,defmacro*-public
-set lw+=use-modules,define-module
-set lw+=define-method,define-class
-set lw+=define-markup-command,define-markup-list-command
-set lw+=define-safe-public,define-music-function
-set lw+=def-grace-function
+setlocal lw+=define-public,define*-public
+setlocal lw+=define*,lambda*,let-keywords*
+setlocal lw+=defmacro,defmacro*,define-macro
+setlocal lw+=defmacro-public,defmacro*-public
+setlocal lw+=use-modules,define-module
+setlocal lw+=define-method,define-class
+setlocal lw+=define-markup-command,define-markup-list-command
+setlocal lw+=define-safe-public,define-music-function
+setlocal lw+=def-grace-function
" These forms should not influence indenting
-set lw-=if
-set lw-=set!
+setlocal lw-=if
+setlocal lw-=set!
" Try to highlight all ly: procedures
syn match schemeFunc "ly:[^) ]\+"
@end example
+For documentation work on texinfo files, identify the file
+extensions used as texinfo files in your @file{.vim/filetype.vim}:
+
+@example
+if exists("did_load_filetypes")
+ finish
+endif
+augroup filetypedetect
+ au! BufRead,BufNewFile *.itely setfiletype texinfo
+ au! BufRead,BufNewFile *.itexi setfiletype texinfo
+ au! BufRead,BufNewFile *.tely setfiletype texinfo
+augroup END
+@end example
+
+and add these settings in @file{.vim/after/ftplugin/texinfo.vim}:
+
+@example
+setlocal expandtab
+setlocal shiftwidth=2
+setlocal textwidth=66
+@end example
@node Naming conventions
@subsection Naming Conventions
@code{\consist}-ed (the only exception is if you set
@code{must-be-last} to @code{#t}).
-If useful things are to be done to the acknowledged grobs, this
-should be deferred until all the acknowledging has finished, i.e.,
-store the acknowledged grobs and process the information in a
-@code{process-acknowledged ()} or @code{stop-translation-timestep ()}
-function.
+There will always be a call to @code{process-acknowledged ()} whenever
+grobs have been created, and @emph{reading} stuff from grobs should be
+delayed until then since other acknowledgers might @emph{write} stuff
+into a grob even after your acknowledger has been called. So the basic
+workflow is to use the various acknowledgers to @emph{record} the grobs
+you are interested in and @emph{write} stuff into them (or do read/write
+stuff that more or less is accumulative and/or really unrelated to other
+engravers), and then use the @code{process-acknowledged ()} hook for
+processing (including @emph{reading}) the grobs you had recorded.
+
+You can create new grobs in @code{process-acknowledged ()}. That will lead
+to a new cycle of @code{acknowledger ()} calls followed by a new cycle of
+@code{process-acknowledged ()} calls.
+
+Only when all those cycles are over is @code{stop-translator-timestep ()}
+called, and then creating grobs is no longer an option. You can still
+@q{process} parts of the grob there (if that means just reading out
+properties and possibly setting context properties based on them) but
+@code{stop-translation-timestep ()} is a cleanup hook, and other engravers
+might have already cleaned up stuff you might have wanted to use.
+Creating grobs in there is not possible since engravers and other code may
+no longer be in a state where they could process them, possibly causing
+a crash.
@node Engraver declaration/documentation
@end example
@noindent
-which would result in the number 24 being stored in the
-LilyPond (and Scheme) variable @code{twentyFour}.
-
-The usual way to refer to LilyPond variables is to call them using a
-backslash, i.e., @code{\twentyFour} (see @ref{LilyPond Scheme syntax}).
-Since this creates a copy of the value for most of LilyPond's internal
-types, in particular music expressions, music functions don't usually
-create copies of material they change. For this reason, music
-expressions given with @code{#} should usually not contain material that
-is not either created from scratch or explicitly copied rather than
-directly referenced.
+which would result in the number @emph{24} being stored in the LilyPond
+(and Scheme) variable @code{twentyFour}.
+
+Scheme allows modifying complex expressions in-place and LilyPond makes
+use of this @q{in-place modification} when using music functions. But
+when music expressions are stored in variables rather than entered
+directly the usual expectation, when passing them to music functions,
+would be that the original value is unmodified. So when referencing a
+music variable with leading backslash (such as @code{\twentyFour}),
+LilyPond creates a copy of that variable's music value for use in the
+surrounding music expression rather than using the variable's value
+directly.
+
+Therefore, Scheme music expressions written with the @code{#} syntax
+should be used for material that is created @q{from scratch} (or that is
+explicitly copied) rather than being used, instead, to directly
+reference material.
+
+@seealso
+Extending:
+@ref{LilyPond Scheme syntax}.
+
@node Input variables and Scheme
@subsection Input variables and Scheme
Font size changes are achieved by scaling the design size that is
closest to the desired size. The standard font size (for
@w{@code{font-size = 0}}) depends on the standard staff height.
-For a 20pt staff, a 11pt font is selected.
+For a 20pt staff, an 11pt font is selected.
@predefined
that has the next @code{\<} or @code{\>} assigned to it. The next
hairpin will then start at the right edge of the same note
instead of the usual left edge had it been terminated with @code{\!}
-before.
+before. A hairpin ending on a downbeat will stop at the preceding bar line.
@lilypond[verbatim,quote]
\relative {
@snippets
+@cindex hairpins at bar lines
+
@lilypondfile[verbatim,quote,texidoc,doctitle]
{setting-hairpin-behavior-at-bar-lines.ly}
slurs may overlap a regular slur, see @ref{Phrasing slurs}. When
multiple regular slurs are needed in a single @code{Voice},
matching slur starts and ends need to be labelled by preceding
-them with @code{\=} followed by an identifying number or string.
+them with @code{\=} followed by an identifying key (a symbol or
+non-negative integer).
@lilypond[verbatim,quote]
\fixed c' {
@end lilypond
@knownissues
-Manual ties inside @code{\retrograde} will be broken and
-generate warnings. Some ties can be generated automatically
-by enabling @ref{Automatic note splitting}.
+@code{\retrograde} is a rather simple tool. Since many events are
+@q{mirrored} rather than exchanged, tweaks and directional
+modifiers for opening spanners need to be added at the matching
+closing spanners: @code{^(} needs to be ended by @code{^)}, every
+@code{\<} or @code{\cresc} needs to be ended by @code{\!} or
+@code{\endcr}, every @code{\>} or @code{\decr} needs to be ended
+by @code{\enddecr}. Property-changing commands/overrides with a
+lasting effect will likely cause surprises.
@seealso
Notation Reference:
>>
@end lilypond
-@warning{Lyrics, spanners (such as slurs, ties, hairpins, etc.) cannot be
-created @q{across} voices.}
+@warning{Lyrics and spanners (such as slurs, ties, hairpins, etc.) cannot
+be created @q{across} voices.}
@subsubsubheading Identical rhythms
@knownissues
Checking to make sure that text scripts and lyrics are within the
-margins requires additonal calculations. In cases where slightly faster
+margins requires additional calculations. In cases where slightly faster
performance is desired, use
@example
@file{scm/markup.scm}.
@knownissues
-Syntax errors for markup mode can be confusing.
+Syntax error messages for markup mode can be confusing.
@node Selecting font and font size
@funindex \magnify
The font size can be altered, relative to the global staff size, in a
-number of different ways
+number of different ways.
-It can be set to predefined size,
+It can be set to predefined size.
@lilypond[quote,verbatim]
\relative b' {
}
@end lilypond
-It can be set relative to its previous value,
+It can be set relative to its previous value.
@lilypond[quote,verbatim]
\relative b' {
@end lilypond
It can be increased or decreased relative to the value set by the
-global staff size,
+global staff size.
@lilypond[quote,verbatim]
\relative b' {
@end lilypond
It can also be set to a fixed point-size, regardless of the global staff
-size,
+size.
@lilypond[quote,verbatim]
\relative b' {
--- /dev/null
+\version "2.19.48"
+\header {
+ lsrtags = "contexts-and-engravers, staff-notation"
+ texidoc = "
+Using @{MarkLine} contexts (such as in
+@uref{http://lsr.di.unimi.it/LSR/Item?id=1010, LSR1010}) in a
+Frenched score can be problematic if all the staves between two
+@code{MarkLine}s are removed in one system. The
+@code{Keep_alive_together_engraver} can be used within each
+@code{StaffGroup} to keep the @code{MarkLine} alive only as long
+as the other staves in the group stay alive.
+"
+ doctitle = "Using marklines in a Frenched score"
+}
+bars = {
+ \tempo "Allegro" 4=120
+ s1*2
+ \repeat unfold 5 { \mark \default s1*2 }
+ \bar "||"
+ \tempo "Adagio" 4=40
+ s1*2
+ \repeat unfold 8 { \mark \default s1*2 }
+ \bar "|."
+}
+winds = \repeat unfold 120 { c''4 }
+trumpet = { \repeat unfold 8 g'2 R1*16 \repeat unfold 4 g'2 R1*8 }
+trombone = { \repeat unfold 4 c'1 R1*8 d'1 R1*17 }
+strings = \repeat unfold 240 { c''8 }
+
+#(set-global-staff-size 16)
+\paper {
+ systems-per-page = 5
+ ragged-last-bottom = ##f
+}
+
+\layout {
+ indent = 15\mm
+ short-indent = 5\mm
+ \context {
+ \name MarkLine
+ \type Engraver_group
+ \consists Output_property_engraver
+ \consists Axis_group_engraver
+ \consists Mark_engraver
+ \consists Metronome_mark_engraver
+ \override VerticalAxisGroup.remove-empty = ##t
+ \override VerticalAxisGroup.remove-layer = #'any
+ \override VerticalAxisGroup.staff-affinity = #DOWN
+ \override VerticalAxisGroup.nonstaff-relatedstaff-spacing.basic-distance = 1
+ keepAliveInterfaces = #'()
+ }
+ \context {
+ \Staff
+ \override VerticalAxisGroup.remove-empty = ##t
+ \override VerticalAxisGroup.remove-layer = ##f
+ }
+ \context {
+ \StaffGroup
+ \accepts MarkLine
+ \consists Keep_alive_together_engraver
+ }
+ \context {
+ \Score
+ \remove Mark_engraver
+ \remove Metronome_mark_engraver
+ }
+}
+
+\score {
+ <<
+ \new StaffGroup = "winds" \with {
+ instrumentName = "Winds"
+ shortInstrumentName = "Winds"
+ } <<
+ \new MarkLine \bars
+ \new Staff \winds
+ >>
+ \new StaffGroup = "brass" <<
+ \new MarkLine \bars
+ \new Staff = "trumpet" \with {
+ instrumentName = "Trumpet"
+ shortInstrumentName = "Tpt"
+ } \trumpet
+ \new Staff = "trombone" \with {
+ instrumentName = "Trombone"
+ shortInstrumentName = "Tbn"
+ } \trombone
+ >>
+ \new StaffGroup = "strings" \with {
+ instrumentName = "Strings"
+ shortInstrumentName = "Strings"
+ } <<
+ \new MarkLine \bars
+ \new Staff = "strings" { \strings }
+ >>
+ >>
+}
@c used for news about the upcoming release; see CG 10.2
@newsItem
-@subheading LilyPond 2.19.46 released @emph{July 26, 2016}
+@subheading LilyPond 2.19.48 released @emph{September 13, 2016}
We are happy to announce the release of LilyPond
-2.19.46. This release includes a number of enhancements, and contains some
+2.19.48. This release includes a number of enhancements, and contains some
work in progress. You will have access to the very latest features, but
some may be incomplete, and you may encounter bugs and crashes. If you
require a stable version of LilyPond, we recommend using the 2.18
* don't duplicate entries from news-front.itexi
@end ignore
+@newsItem
+@subheading LilyPond 2.19.47 released @emph{August 31, 2016}
+
+We are happy to announce the release of LilyPond
+2.19.47. This release includes a number of enhancements, and contains some
+work in progress. You will have access to the very latest features, but
+some may be incomplete, and you may encounter bugs and crashes. If you
+require a stable version of LilyPond, we recommend using the 2.18
+version.
+
+@newsEnd
+
+@newsItem
+@subheading LilyPond 2.19.46 released @emph{July 26, 2016}
+
+We are happy to announce the release of LilyPond
+2.19.46. This release includes a number of enhancements, and contains some
+work in progress. You will have access to the very latest features, but
+some may be incomplete, and you may encounter bugs and crashes. If you
+require a stable version of LilyPond, we recommend using the 2.18
+version.
+
+@newsEnd
+
@newsItem
@subheading LilyPond 2.19.45 released @emph{July 09, 2016}
PACKAGE_NAME=LilyPond
MAJOR_VERSION=2
MINOR_VERSION=19
-PATCH_LEVEL=47
+PATCH_LEVEL=49
MY_PATCH_LEVEL=
VERSION_STABLE=2.18.2
-VERSION_DEVEL=2.19.46
+VERSION_DEVEL=2.19.48
Offset direction () const;
Offset swapped () const;
- Real arg () const;
Real angle_degrees () const;
Real length () const;
bool is_sane () const;
IMPLEMENT_ARITHMETIC_OPERATOR (Offset, *);
Offset complex_multiply (Offset, Offset);
-Offset complex_divide (Offset, Offset);
-Offset complex_exp (Offset);
+Offset offset_directed (Real);
inline Offset
Offset::operator *= (Offset z2)
return z;
}
-Offset
-complex_conjugate (Offset o)
-{
- o[Y_AXIS] = -o[Y_AXIS];
- return o;
-}
-
-Offset
-complex_divide (Offset z1, Offset z2)
-{
- z2 = complex_conjugate (z2);
- Offset z = complex_multiply (z1, z2);
- z *= 1 / z2.length ();
- return z;
-}
-
-Offset
-complex_exp (Offset o)
-{
- Real s = sin (o[Y_AXIS]);
- Real c = cos (o[Y_AXIS]);
-
- Real r = exp (o[X_AXIS]);
-
- return Offset (r * c, r * s);
-}
-
-Real
-Offset::arg () const
+static inline Real
+atan2d (Real y, Real x)
{
- return atan2 (coordinate_a_[Y_AXIS], coordinate_a_[X_AXIS]);
+ return atan2 (y, x) * (180.0 / M_PI);
}
Real
Offset::angle_degrees () const
{
- return arg () * 180 / M_PI;
+ Real x = coordinate_a_ [X_AXIS];
+ Real y = coordinate_a_ [Y_AXIS];
+
+ // We keep in the vicinity of multiples of 45 degrees here: this is
+ // where straightforward angles for straightforward angular
+ // relations are most expected. The factors of 2 employed in the
+ // comparison are not really perfect for that: sqrt(2)+1 would be
+ // the factor giving exact windows of 45 degrees rather than what we
+ // have here. It's just that 2 is likely to generate nicer code
+ // than 2.4 and the exact handover does not really matter.
+ //
+ // Comparisons here are chosen appropriately to let infinities end
+ // up in their "exact" branch. As opposed to the normal atan2
+ // function behavior, this makes "competing" infinities result in
+ // NAN angles.
+ if (y < 0.0)
+ {
+ if (2*x < -y)
+ if (-x > -2*y) // x < 0, y < 0, |x| > |2y|
+ return -180 + atan2d (-y, -x);
+ else if (-2*x >= -y) // x < 0, y < 0, |y| < |2x| <= |4y|
+ return -135 + atan2d (x - y, -y - x);
+ else // y < 0, |y| >= |2x|
+ return -90 + atan2d (x, -y);
+ else if (x <= -2*y) // x > 0, y < 0, |y| <= |2x| < |4y|
+ return -45 + atan2d (x + y, x - y);
+ // Drop through for y < 0, x > |2y|
+ }
+ else if (y > 0.0)
+ {
+ if (2*x < y)
+ if (-x > 2*y) // x < 0, y >= 0, |x| > |2y|
+ return 180 - atan2d (y, -x);
+ else if (-2*x >= y) // x < 0, y >= 0, |y| < |2x| <= |4y|
+ return 135 - atan2d (x + y, y - x);
+ else // y >= 0, |y| >= |2x|
+ return 90 - atan2d (x, y);
+ else if (x <= 2*y) // x >= 0, y >= 0, |y| < |2x| < |4y|
+ return 45 - atan2d (x - y, x + y);
+ // Drop through for y > 0, x > |2y|
+ }
+ else
+ // we return 0 for (0,0). NAN would be an option but is a
+ // nuisance for getting back to rectangular coordinates. Strictly
+ // speaking, this argument would be just as valid for (+inf.0,
+ // +inf.0), but then infinities are already an indication of a
+ // problem in LilyPond.
+ return (x < 0.0) ? 180 : 0;
+ return atan2d (y, x);
}
+
+
/**
euclidian vector length / complex modulus
*/
{
return Offset (coordinate_a_[Y_AXIS], coordinate_a_[X_AXIS]);
}
+
+Offset
+offset_directed (Real angle)
+{
+ if (angle <= -360.0 || angle >= 360.0)
+ angle = fmod (angle, 360.0);
+ // Now |angle| < 360.0, and the absolute size is not larger than
+ // before, so we haven't lost precision.
+ if (angle <= -180.0)
+ angle += 360.0;
+ else if (angle > 180.0)
+ angle -= 360.0;
+ // Now -180.0 < angle <= 180.0 and we still haven't lost precision.
+ // We don't work with angles greater than 45 degrees absolute in
+ // order to minimize how rounding errors of M_PI/180 affect the
+ // result. That way, at least angles that are a multiple of 90
+ // degree deliver the expected results.
+ //
+ // Sign of the sine is chosen to avoid -0.0 in results. This
+ // version delivers exactly equal magnitude on x/y for odd multiples
+ // of 45 degrees at the cost of losing some less obvious invariants.
+
+ if (angle > 0)
+ if (angle > 90)
+ return Offset (sin ((90 - angle) * M_PI/180.0),
+ sin ((180 - angle) * M_PI/180.0));
+ else
+ return Offset (sin ((90 - angle) * M_PI/180.0),
+ sin (angle * M_PI/180.0));
+ else if (angle < -90)
+ return Offset (sin ((90 + angle) * M_PI/180.0),
+ sin ((-180 - angle) * M_PI/180.0));
+ else
+ return Offset (sin ((90 + angle) * M_PI/180.0),
+ sin (angle * M_PI/180.0));
+}
--- /dev/null
+\version "2.19.48"
+
+\header {
+ texidoc = "The @code{VerticalAxisGroup.remove-layer} property
+ can be used to keep staves alive with reference to other staves
+ in the @code{Keep_alive_together_engraver} group."
+}
+
+\layout {
+ indent = 40\mm
+ short-indent = 15\mm
+}
+
+\score {
+ <<
+ \new Staff \with {
+ instrumentName = "Continuous"
+ shortInstrumentName = "cont"
+ } { \repeat unfold 104 g'4 \bar "|." }
+ \new StaffGroup \with {
+ \consists Keep_alive_together_engraver
+ } <<
+ \new Staff \with {
+ keepAliveInterfaces = #'()
+ instrumentName = \markup \center-column { "Alive with A or B" }
+ shortInstrumentName = "with A or B"
+ \override VerticalAxisGroup.remove-empty = ##t
+ \override VerticalAxisGroup.remove-first = ##t
+ \override VerticalAxisGroup.remove-layer = #'any
+ } { \repeat unfold 104 c''4 }
+ \new Staff \with {
+ instrumentName = "A"
+ shortInstrumentName = "A"
+ \override VerticalAxisGroup.remove-empty = ##t
+ \override VerticalAxisGroup.remove-first = ##t
+ \override VerticalAxisGroup.remove-layer = ##f
+ } {
+ \repeat unfold 16 c'4
+ R1*4
+ \repeat unfold 16 c'4
+ R1*14
+ }
+ \new Staff \with {
+ keepAliveInterfaces = #'()
+ instrumentName = \markup \center-column { "Alive with A" }
+ shortInstrumentName = "with A"
+ \override VerticalAxisGroup.remove-empty = ##t
+ \override VerticalAxisGroup.remove-first = ##t
+ \override VerticalAxisGroup.remove-layer = #'above
+ } { \repeat unfold 104 c''4 }
+ \new Staff \with {
+ instrumentName = "B"
+ shortInstrumentName = "B"
+ \override VerticalAxisGroup.remove-empty = ##t
+ \override VerticalAxisGroup.remove-first = ##t
+ \override VerticalAxisGroup.remove-layer = ##f
+ } {
+ R1*8
+ \repeat unfold 16 c'4
+ R1*13
+ c'1
+ }
+ >>
+ >>
+}
--- /dev/null
+\version "2.18.0"
+
+\header {
+ texidoc = "@code{\\retrograde} can deal with crescendo and
+ decrescendo as long as they are properly paired with
+ @code{\\endcr}/@code{\\!} and @code{\\enddecr}. Direction modifiers
+ on slurs like @code{^(} need to be repeated as @code{^)} at the end.
+ Ties and glissandi work mostly (in-chord ties are turned into
+ ordinary per-chord/note ties, however)."
+}
+
+\layout { ragged-right = ##t }
+
+motif =
+\relative {
+ \override TextSpanner.bound-details.left.text = "motif"
+ <c' e>2~\startTextSpan c16\< d^( e f~ f4:32^)\!\> |
+ <<
+ \context Voice = "voice" {
+ <g~ b>4 g8\glissando f\stopTextSpan\enddecr }
+ \\
+ { c2 }
+ >>
+}
+
+\new Voice = "voice" {
+ \motif
+ \override TextSpanner.bound-details.left.text = "retrograde motif"
+ \retrograde \motif \bar "|."
+}
(SchemeTextSpanEvent
. ((description . "Used to signal where scheme text spanner brackets
start and stop.")
- (types . (scheme-text-span-event span-event event))
+ (types . (post-event scheme-text-span-event span-event event))
))
))
@code{FretBoards} will print those micro-tones only if they can be found in the
chosen settings for @code{stringTunings}, otherwise a warning (surpressed here)
will be printed and an empty @code{FretBoard} returned. Which should be the
-case here for the first pitch: @code{gih}"
+case for the last four of the examples pitches.
+Micro-tones assigned to strings work nicely."
}
#(ly:set-option 'warning-as-error #f)
-#(ly:expect-warning (_ "No string for pitch ~a (given frets ~a)") #{ gih #} '())
+#(for-each
+ (lambda (pitch)
+ (ly:expect-warning (_ "No string for pitch "))
+ (ly:expect-warning (_ "Requested string for pitch requires negative fret"))
+ (ly:expect-warning (_ "Ignoring string request and recalculating.")))
+ (iota 4))
\layout {
\context {
custom-tuning = \stringTuning <e, a, d ges beh eeh'>
mus = \relative {
- gih4
- eeses'
+ eeses'4
eeseh
ees
eeh
eis
eisih
eisis
+ geseh,,\6
+ geh\6
+ gih\6
+ gisih\6
}
<<
Real height_limit = 1.5;
Real ratio = .33;
Bezier curve = slur_shape (dy, height_limit, ratio);
- curve.rotate (M_PI / 2);
+ curve.rotate (90.0);
Stencil mol (Lookup::slur (curve, lt, lt, dash_definition));
mol.translate_axis (heads[LEFT], Y_AXIS);
Real offset = robust_scm2double (prev_offset, 0.0);
Interval rest_extent = rest->extent (rest, Y_AXIS);
- rest_extent.translate (offset + rest->get_parent (Y_AXIS)->relative_coordinate (common_y, Y_AXIS));
+ rest_extent.translate (offset + rest->parent_relative (common_y, Y_AXIS));
Real rest_dim = rest_extent[d];
Real minimum_distance
}
void
-rotate (vector<Offset> *array, Real phi)
+rotate (vector<Offset> *array, Real deg)
{
- Offset rot (complex_exp (Offset (0, phi)));
+ Offset rot (offset_directed (deg));
for (vsize i = 0; i < array->size (); i++)
(*array)[i] = complex_multiply (rot, (*array)[i]);
}
}
void
-Bezier::rotate (Real phi)
+Bezier::rotate (Real deg)
{
- Offset rot (complex_exp (Offset (0, phi)));
+ Offset rot (offset_directed (deg));
for (int i = 0; i < CONTROL_COUNT; i++)
control_[i] = complex_multiply (rot, control_[i]);
}
{
Interval x_ext = fingerings[i]->extent(common[X_AXIS], X_AXIS);
Interval y_ext = fingerings[i]->extent(fingerings[i], Y_AXIS);
- Real parent_y = fingerings[i]->get_parent(Y_AXIS)
- ->relative_coordinate(common[Y_AXIS], Y_AXIS);
+ Real parent_y = fingerings[i]->parent_relative (common[Y_AXIS], Y_AXIS);
// Checking only between sequential neighbors, seems good enough
if (!intersection(x_ext, prev_x_ext).is_empty())
/* We catch PARENT_L_ == nil case with this, but we crash if we did
not ask for the absolute coordinate (ie. REFP == nil.) */
- Real off = get_offset (a);
- if (refp == dim_cache_[a].parent_)
- return off;
- if (dim_cache_[a].parent_ != NULL)
- off += dim_cache_[a].parent_->relative_coordinate (refp, a);
+ return get_offset (a) + parent_relative (refp, a);
+}
- return off;
+Real
+Grob::parent_relative (Grob const *refp, Axis a) const
+{
+ if (Grob *p = get_parent (a))
+ return p->relative_coordinate (refp, a);
+ return 0.0;
}
Real
ADD_INTERFACE (Hara_kiri_group_spanner,
"A group spanner that keeps track of interesting items. If it"
" doesn't contain any after line breaking, it removes itself"
- " and all its children. Children may be prioritized in layers"
- " via @code{remove-layer}, in which case only the"
- " lowest-numbered non-empty layer is retained.",
+ " and all its children. Greater control can be exercised via"
+ " @code{remove-layer} which can prioritize layers so only the"
+ " lowest-numbered non-empty layer is retained; make the layer"
+ " independent of the group; or make it dependent on any other"
+ " member of the group",
/* properties */
"items-worth-living "
};
void scale (vector<Offset> *array, Real xscale, Real yscale);
-void rotate (vector<Offset> *array, Real phi);
+void rotate (vector<Offset> *array, Real deg);
void translate (vector<Offset> *array, Offset o);
Bezier slur_shape (Real width, Real height_limit,
/* offsets */
void translate_axis (Real, Axis);
Real relative_coordinate (Grob const *refp, Axis) const;
+ Real parent_relative (Grob const *refp, Axis) const;
Real pure_relative_y_coordinate (Grob const *refp, int start, int end);
Real maybe_pure_coordinate (Grob const *refp, Axis a, bool pure, int start, int end);
void stop_translation_timestep ();
void process_music ();
- bool can_create_slur (const string&, vsize, vsize *, Stream_event *);
- void create_slur (const string &spanner_id, Event_info evi, Grob *g_cause, Direction dir, bool left_broken);
+ bool can_create_slur (SCM, vsize, vsize *, Stream_event *);
+ void create_slur (SCM spanner_id, Event_info evi, Grob *g_cause, Direction dir, bool left_broken);
bool try_to_end (Event_info evi);
virtual void set_melisma (bool);
#include "engraver.hh"
#include "grob.hh"
#include "grob-array.hh"
+#include "international.hh"
#include "translator.icc"
{
if (i == j)
continue;
+
+ if (scm_is_symbol (this_layer))
+ {
+ if (scm_is_eq (this_layer, ly_symbol2scm ("any")))
+ {
+ // layer is kept alive by any other layer
+ live->add (group_spanners_[j]);
+ continue;
+ }
+ else if (scm_is_eq (this_layer, ly_symbol2scm ("above")))
+ {
+ // layer is kept alive by the layer preceding it
+ if (i == j + 1)
+ live->add (group_spanners_[j]);
+ continue;
+ }
+ else if (scm_is_eq (this_layer, ly_symbol2scm ("below")))
+ {
+ // layer is kept alive by the layer following it
+ if (i == j - 1)
+ live->add (group_spanners_[j]);
+ continue;
+ }
+ else
+ {
+ group_spanners_[i]->warning (_f ("unknown remove-layer value `%s'",
+ ly_symbol2string (this_layer).c_str ()));
+ continue;
+ }
+ }
+
SCM that_layer = group_spanners_[j]->get_property ("remove-layer");
+
if (scm_is_false (that_layer))
continue;
if (!scm_is_integer (this_layer))
{
- // Unspecified layers are kept alive by anything else
+ // unset layers are kept alive by all but ignored layers
live->add (group_spanners_[j]);
continue;
}
}
while (len + elt_len < dz.length ());
- line.rotate (dz.arg (), Offset (LEFT, CENTER));
+ line.rotate (dz.angle_degrees (), Offset (LEFT, CENTER));
line.translate (from);
return line;
calculate the offset for the two beziers that make the sandwich
for the slur
*/
- Real alpha = (curve.control_[3] - curve.control_[0]).arg ();
+ Offset dir = (curve.control_[3] - curve.control_[0]).direction ();
Bezier back = curve;
- Offset perp = curvethick * complex_exp (Offset (0, alpha + M_PI / 2)) * 0.5;
+ Offset perp = 0.5 * curvethick * Offset (-dir[Y_AXIS], dir[X_AXIS]);
back.control_[1] += perp;
back.control_[2] += perp;
SCM check_scheme_arg (Lily_parser *parser, Input loc,
SCM arg, SCM args, SCM pred, SCM disp = SCM_UNDEFINED);
SCM make_music_from_simple (Lily_parser *parser, Input loc, SCM pitch);
-SCM loc_on_music (Lily_parser *parser, Input loc, SCM arg);
+SCM loc_on_copy (Lily_parser *parser, Input loc, SCM arg);
SCM make_chord_elements (Input loc, SCM pitch, SCM dur, SCM modification_list);
SCM make_chord_step (SCM step, Rational alter);
SCM make_simple_markup (SCM a);
LOOKUP_IDENTIFIER
| LOOKUP_IDENTIFIER '.' symbol_list_rev
{
- $$ = loc_on_music (parser, @$,
- nested_property ($1, scm_reverse_x ($3, SCM_EOL)));
+ $$ = loc_on_copy (parser, @$,
+ nested_property ($1, scm_reverse_x ($3, SCM_EOL)));
}
;
$$ = scm_cons ($$, $3);
else
{
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (SCM_ARG, $4, @4);
}
}
{
$$ = scm_cons ($4, $3);
} else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (EVENT_IDENTIFIER, $4, @4);
}
}
} else if (scm_is_true (scm_call_1 ($2, $4)))
$$ = scm_cons ($4, $3);
else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (PITCH_IDENTIFIER, $4, @4);
}
}
} else if (scm_is_true (scm_call_1 ($2, $4)))
$$ = scm_cons ($4, $3);
else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (TONICNAME_PITCH, $4, @4);
}
}
if (scm_is_true (scm_call_1 ($2, $4)))
$$ = scm_cons ($4, $3);
else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (SCM_IDENTIFIER, $4, @4);
}
}
($2, make_music_from_simple (parser, @4, d))))
MYREPARSE (@4, $2, DURATION_ARG, d);
else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (UNSIGNED, $4, @4);
}
} else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (UNSIGNED, $4, @4);
}
}
$$ = $3;
MYREPARSE (@4, $2, REAL, $4);
} else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (REAL, $4, @4);
}
}
{
$$ = scm_cons ($4, $3);
} else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (NUMBER_IDENTIFIER, $4, @4);
}
}
if (scm_is_true (scm_call_1 ($2, $$)))
$$ = scm_cons ($$, $3);
else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (UNSIGNED, $5, @5);
parser->lexer_->push_extra_token (@4, '-');
}
MYREPARSE (@5, $2, REAL, n);
$$ = $3;
} else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (REAL, n, @5);
}
}
if (scm_is_true (scm_call_1 ($2, n))) {
$$ = scm_cons (n, $3);
} else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (NUMBER_IDENTIFIER, n, @5);
}
}
($2, make_music_from_simple (parser, @4, $4))))
MYREPARSE (@4, $2, DURATION_ARG, $4);
else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (DURATION_IDENTIFIER, $4, @4);
}
}
else
$$ = scm_cons (res, $3);
else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (SCM_IDENTIFIER, $4, @4);
}
}
else
$$ = scm_cons (res, $3);
else {
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (STRING, $4, @4);
}
}
function_arglist_nonbackup
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup DEFAULT
{
- $$ = scm_cons (loc_on_music (parser, @4, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @4, $1), $3);
}
;
function_arglist_nonbackup
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup
{
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
}
;
function_arglist_backup
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup DEFAULT
{
- $$ = scm_cons (loc_on_music (parser, @4, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @4, $1), $3);
}
| function_arglist_skip_backup BACKUP
;
function_arglist_backup
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup
{
- $$ = scm_cons (loc_on_music (parser, @3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
}
;
return args;
}
-SCM loc_on_music (Lily_parser *parser, Input loc, SCM arg)
+SCM loc_on_copy (Lily_parser *parser, Input loc, SCM arg)
{
if (Music *m = unsmob<Music> (arg))
{
m->set_spot (parser->lexer_->override_input (loc));
return m->unprotect ();
}
+ if (Book *b = unsmob<Book> (arg))
+ {
+ b = b->clone ();
+ b->origin ()->set_spot (parser->lexer_->override_input (loc));
+ return b->unprotect ();
+ }
+ if (Context_def *cd = unsmob<Context_def> (arg))
+ {
+ cd = cd->clone ();
+ cd->origin ()->set_spot (parser->lexer_->override_input (loc));
+ return cd->unprotect ();
+ }
+ if (Output_def *od = unsmob<Output_def> (arg))
+ {
+ od = od->clone ();
+ od->input_origin_ = parser->lexer_->override_input (loc);
+ return od->unprotect ();
+ }
+ if (Score *s = unsmob<Score> (arg))
+ {
+ s = s->clone ();
+ s->origin ()->set_spot (parser->lexer_->override_input (loc));
+ return s->unprotect ();
+ }
+ if (Context_mod *cm = unsmob<Context_mod> (arg))
+ {
+ return cm->smobbed_copy ();
+ }
return arg;
}
// skyline will likely be of infinite width anyway
// and we don't want to prematurely trigger H spacing
Real xc = a == X_AXIS || (pure && dynamic_cast<Spanner *> (me))
- ? me->get_parent (X_AXIS)->relative_coordinate (common[X_AXIS], X_AXIS)
+ ? me->parent_relative (common[X_AXIS], X_AXIS)
: me->relative_coordinate (common[X_AXIS], X_AXIS);
// same here, for X_AXIS spacing, if it's happening, it should only be
// before line breaking. because there is no thing as "pure" x spacing,
if (unsmob<Skyline_pair> (sp))
{
Real xc = pure && dynamic_cast<Spanner *> (e)
- ? e->get_parent (X_AXIS)->relative_coordinate (common[X_AXIS], X_AXIS)
+ ? e->parent_relative (common[X_AXIS], X_AXIS)
: e->relative_coordinate (common[X_AXIS], X_AXIS);
// same logic as above
// we assume horizontal spacing is always pure
Real fit_factor = 0.0;
Offset x0 = curve.control_[0];
curve.translate (-x0);
- curve.rotate (-dz_unit.arg ());
+ curve.rotate (-dz_unit.angle_degrees ());
curve.scale (1, d);
Interval curve_xext;
}
void
-Slur_engraver::create_slur (const string &spanner_id, Event_info evi, Grob *g_cause, Direction dir, bool left_broken)
+Slur_engraver::create_slur (SCM spanner_id, Event_info evi, Grob *g_cause, Direction dir, bool left_broken)
{
Grob *ccc = left_broken
? unsmob<Grob> (get_property ("currentCommandColumn"))
: 0; // efficiency
SCM cause = evi.slur_ ? evi.slur_->self_scm () : g_cause->self_scm ();
Spanner *slur = make_spanner (grob_symbol (), cause);
- slur->set_property ("spanner-id", ly_string2scm (spanner_id));
+ slur->set_property ("spanner-id", spanner_id);
if (dir)
set_grob_direction (slur, dir);
if (left_broken)
{
set_grob_direction (slur, DOWN);
slur = make_spanner (grob_symbol (), cause);
- slur->set_property ("spanner-id", ly_string2scm (spanner_id));
+ slur->set_property ("spanner-id", spanner_id);
set_grob_direction (slur, UP);
if (left_broken)
slur->set_bound (LEFT, ccc);
}
bool
-Slur_engraver::can_create_slur (const string &id, vsize old_slurs, vsize *event_idx, Stream_event *ev)
+Slur_engraver::can_create_slur (SCM id, vsize old_slurs, vsize *event_idx, Stream_event *ev)
{
for (vsize j = slurs_.size (); j--;)
{
Direction updown = to_dir (ev->get_property ("direction"));
// Check if we already have a slur with the same spanner-id.
- if (id == robust_scm2string (slur->get_property ("spanner-id"), ""))
+ if (ly_is_equal (id, slur->get_property ("spanner-id")))
{
if (j < old_slurs)
{
bool
Slur_engraver::try_to_end (Event_info evi)
{
- string id = robust_scm2string (evi.slur_->get_property ("spanner-id"), "");
+ SCM id = evi.slur_->get_property ("spanner-id");
// Find the slurs that are ended with this event (by checking the spanner-id)
bool ended = false;
for (vsize j = slurs_.size (); j--;)
{
- if (id == robust_scm2string (slurs_[j]->get_property ("spanner-id"), ""))
+ if (ly_is_equal (id, slurs_[j]->get_property ("spanner-id")))
{
ended = true;
end_slurs_.push_back (slurs_[j]);
{
for (vsize i = 0; i < stop_events_.size (); i++)
{
- string id = robust_scm2string
- (stop_events_[i].slur_->get_property ("spanner-id"), "");
+ SCM id = stop_events_[i].slur_->get_property ("spanner-id");
bool ended = try_to_end (stop_events_[i]);
if (ended)
{
// Ignore redundant stop events for this id
for (vsize j = stop_events_.size (); --j > i;)
{
- if (id == robust_scm2string
- (stop_events_[j].slur_->get_property ("spanner-id"), ""))
+ if (ly_is_equal (id, stop_events_[j].slur_->get_property ("spanner-id")))
stop_events_.erase (stop_events_.begin () + j);
}
}
for (vsize i = start_events_.size (); i--;)
{
Stream_event *ev = start_events_[i].slur_;
- string id = robust_scm2string (ev->get_property ("spanner-id"), "");
+ SCM id = ev->get_property ("spanner-id");
Direction updown = to_dir (ev->get_property ("direction"));
if (can_create_slur (id, old_slurs, &i, ev))
}
}
- dz = os[RIGHT] - os[LEFT];
+ dz = (os[RIGHT] - os[LEFT]).direction ();
for (LEFT_and_RIGHT (d))
{
if (extremes_[d].slur_head_
TODO: parameter */
os[d][X_AXIS]
-= dir_ * extremes_[d].slur_head_x_extent_.length ()
- * sin (dz.arg ()) / 3;
+ * dz[Y_AXIS] / 3;
}
}
expr = scm_cdr (expr);
Real y_rad = robust_scm2double (scm_car (expr), 0.0);
expr = scm_cdr (expr);
+ Offset rad (x_rad, y_rad);
Real start = robust_scm2double (scm_car (expr), 0.0);
expr = scm_cdr (expr);
Real end = robust_scm2double (scm_car (expr), 0.0);
expr = scm_cdr (expr);
bool fill = to_boolean (scm_car (expr));
//////////////////////
- start = M_PI * start / 180;
- end = M_PI * end / 180;
if (end == start)
- end += (2 * M_PI);
- Offset sp (cos (start) * x_rad, sin (start) * y_rad);
- Offset ep (cos (end) * x_rad, sin (end) * y_rad);
+ end += 360;
+ Offset sp (offset_directed (start).scale (rad));
+ Offset ep (offset_directed (end).scale (rad));
//////////////////////
Drul_array<vector<Offset> > points;
int quantization = max (1, (int) (((x_rad * trans.xx) + (y_rad * trans.yy)) * M_PI / QUANTIZATION_UNIT));
for (vsize i = 0; i < 1 + (vsize) quantization; i++)
{
Real ang = linear_map (start, end, 0, quantization, i);
- Offset pt (cos (ang) * x_rad, sin (ang) * y_rad);
+ Offset pt (offset_directed (ang).scale (rad));
Offset inter = pt + d * get_normal ((th/2) * pt.direction ());
pango_matrix_transform_point (&trans, &inter[X_AXIS], &inter[Y_AXIS]);
points[d].push_back (inter);
if (th > 0.0)
{
// beg line cap
- Offset pt (cos (start) * x_rad, sin (start) * y_rad);
+ Offset pt (offset_directed (start).scale (rad));
create_path_cap (boxes,
buildings,
trans,
-get_normal (pt));
// end line cap
- pt = Offset (cos (end) * x_rad, sin (end) * y_rad);
+ pt = offset_directed (end).scale (rad);
create_path_cap (boxes,
buildings,
trans,
#include "font-metric.hh"
#include "libc-extension.hh"
#include "lookup.hh"
+#include "offset.hh"
#include "stencil.hh"
+/*
+ * A few general helpers in degrees
+ */
+
+LY_DEFINE (ly_angle, "ly:angle",
+ 1, 1, 0, (SCM x, SCM y),
+ "Calculates angle in degrees of given vector. With one argument,"
+ " @var{x} is a number pair indicating the vector. With two"
+ " arguments, @var{x} and @var{y} specify the respective coordinates.")
+{
+ Offset off;
+ if (SCM_UNBNDP (y)) {
+ LY_ASSERT_TYPE (is_number_pair, x, 1);
+ off = ly_scm2offset (x);
+ } else {
+ LY_ASSERT_TYPE (scm_is_number, x, 1);
+ LY_ASSERT_TYPE (scm_is_number, y, 2);
+ off = Offset (scm_to_double (x), scm_to_double (y));
+ }
+ return scm_from_double (off.angle_degrees ());
+}
+
+LY_DEFINE (ly_length, "ly:length",
+ 1, 1, 0, (SCM x, SCM y),
+ "Calculates magnitude of given vector. With one argument,"
+ " @var{x} is a number pair indicating the vector. With two"
+ " arguments, @var{x} and @var{y} specify the respective coordinates.")
+{
+ Offset off;
+ if (SCM_UNBNDP (y)) {
+ LY_ASSERT_TYPE (is_number_pair, x, 1);
+ off = ly_scm2offset (x);
+ } else {
+ LY_ASSERT_TYPE (scm_is_number, x, 1);
+ LY_ASSERT_TYPE (scm_is_number, y, 2);
+ off = Offset (scm_to_double (x), scm_to_double (y));
+ }
+ return scm_from_double (off.length ());
+}
+
+LY_DEFINE (ly_directed, "ly:directed",
+ 1, 1, 0, (SCM direction, SCM magnitude),
+ "Calculates an @code{(x . y)} pair with optional @var{magnitude}"
+ " (defaulting to @code{1.0}) and @var{direction} specified either"
+ " as an angle in degrees or a coordinate pair giving the direction. "
+ " If @var{magnitude} is a pair, the respective coordinates are"
+ " scaled independently, useful for ellipse drawings.")
+{
+ Offset res;
+ if (scm_is_pair (direction))
+ {
+ LY_ASSERT_TYPE (is_number_pair, direction, 1);
+ res = ly_scm2offset (direction).direction ();
+ }
+ else
+ {
+ LY_ASSERT_TYPE (scm_is_number, direction, 1);
+ res = offset_directed (scm_to_double (direction));
+ }
+ if (SCM_UNBNDP (magnitude))
+ return ly_offset2scm (res);
+ if (scm_is_pair (magnitude))
+ {
+ LY_ASSERT_TYPE (is_number_pair, magnitude, 2);
+ return ly_offset2scm (res.scale (ly_scm2offset (magnitude)));
+ }
+ LY_ASSERT_TYPE (scm_is_number, magnitude, 2);
+ return ly_offset2scm (scm_to_double (magnitude) * res);
+}
+
+
/*
TODO: naming add/combine.
*/
void
Stencil::rotate (Real a, Offset off)
{
- rotate_degrees (a * 180 / M_PI, off);
+ rotate_degrees (a, off);
}
/*
pts.push_back (Offset (shifted_box.x ().at (RIGHT), shifted_box.y ().at (UP)));
pts.push_back (Offset (shifted_box.x ().at (LEFT), shifted_box.y ().at (UP)));
- const Offset rot = complex_exp (Offset (0, a * M_PI / 180.0));
+ const Offset rot (offset_directed (a));
dim_.set_empty ();
for (vsize i = 0; i < pts.size (); i++)
dim_.add_point (pts[i] * rot + absolute_off);
if (Grob *beam = Stem::get_beam (stems[side]))
(void) beam->get_property ("quantized-positions");
poss[side] = stems[side]->extent (stems[side], Y_AXIS)[get_grob_direction (stems[side])]
- + stems[side]->get_parent (Y_AXIS)->relative_coordinate (commony, Y_AXIS);
+ + stems[side]->parent_relative (commony, Y_AXIS);
}
*dy = poss[RIGHT] - poss[LEFT];
%}
-\version "2.19.46" % necessary for upgrading to future LilyPond versions.
+\version "2.19.48" % necessary for upgrading to future LilyPond versions.
\header{
title = "A scale in LilyPond"
%}
-\version "2.19.46" % necessary for upgrading to future LilyPond versions.
+\version "2.19.48" % necessary for upgrading to future LilyPond versions.
\header{
title = "A scale in LilyPond"
\version "2.17.6"
-startGraceSlur = #(make-music 'SlurEvent 'span-direction START 'spanner-id "grace")
-stopGraceSlur = #(make-music 'SlurEvent 'span-direction STOP 'spanner-id "grace")
+startGraceSlur = #(make-music 'SlurEvent 'span-direction START 'spanner-id 'grace)
+stopGraceSlur = #(make-music 'SlurEvent 'span-direction STOP 'spanner-id 'grace)
startGraceMusic = {
#(define-music-function (music)
(ly:music?)
(_i "Return @var{music} in reverse order.")
- (retrograde-music music))
+ (retrograde-music
+ (expand-repeat-notes!
+ (expand-repeat-chords!
+ (cons 'rhythmic-event
+ (ly:parser-lookup '$chord-repeat-events))
+ music))))
revertTimeSignatureSettings =
#(define-music-function
\version "2.19.29"
"\\=" =
-#(define-event-function (id event) (number-or-string? ly:event?)
+#(define-event-function (id event) (key? ly:event?)
(_i "This sets the @code{spanner-id} property of the following
-@var{event} to the given @var{id} (numbers will be converted to a
-string). This can be used to tell LilyPond how to connect overlapping
+@var{event} to the given @var{id} (non-negative integer or symbol).
+This can be used to tell LilyPond how to connect overlapping
or parallel slurs or phrasing slurs within a single @code{Voice}.
@lilypond[quote,verbatim]
\\fixed c' { c\\=1( d\\=2( e\\=1) f\\=2) }
@end lilypond\n")
- (set! (ly:music-property event 'spanner-id)
- (if (number? id)
- (number->string id)
- id))
+ (set! (ly:music-property event 'spanner-id) id)
event)
startGroup = #(make-span-event 'NoteGroupingEvent START)
#, fuzzy
msgid ""
msgstr ""
-"Project-Id-Version: lilypond 2.19.46\n"
+"Project-Id-Version: lilypond 2.19.48\n"
"Report-Msgid-Bugs-To: http://post.gmane.org/post.php?group=gmane.comp.gnu."
"lilypond.bugs\n"
-"POT-Creation-Date: 2016-07-24 11:09+0100\n"
+"POT-Creation-Date: 2016-09-13 11:07+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
msgid "Encountered unprocessed marker %s\n"
msgstr ""
-#: abc2ly.py:1389 convert-ly.py:85 lilypond-book.py:122 midi2ly.py:1046
+#: abc2ly.py:1389 convert-ly.py:85 lilypond-book.py:122 midi2ly.py:1052
#, python-format
msgid "%s [OPTION]... FILE"
msgstr ""
msgstr ""
#: abc2ly.py:1398 convert-ly.py:92 etf2ly.py:1208 lilypond-book.py:231
-#: midi2ly.py:1097 musicxml2ly.py:2766 main.cc:184
+#: midi2ly.py:1103 musicxml2ly.py:2766 main.cc:184
msgid "show version number and exit"
msgstr ""
#: abc2ly.py:1401 convert-ly.py:96 etf2ly.py:1204 lilypond-book.py:140
-#: midi2ly.py:1064 musicxml2ly.py:2747 main.cc:163
+#: midi2ly.py:1070 musicxml2ly.py:2747 main.cc:163
msgid "show this help and exit"
msgstr ""
-#: abc2ly.py:1404 etf2ly.py:1209 midi2ly.py:1073
+#: abc2ly.py:1404 etf2ly.py:1209 midi2ly.py:1079
msgid "write output to FILE"
msgstr ""
#. or if there is a LilyPond users list or forum in your language
#. "Report bugs in English via %s or in YOUR_LANG via URI"
#: abc2ly.py:1416 convert-ly.py:157 etf2ly.py:1218 lilypond-book.py:258
-#: midi2ly.py:1109 musicxml2ly.py:2909 main.cc:318
+#: midi2ly.py:1115 musicxml2ly.py:2909 main.cc:318
#, c-format, python-format
msgid "Report bugs via %s"
msgstr ""
msgid "make a numbered backup [default: filename.ext~]"
msgstr ""
-#: convert-ly.py:152 etf2ly.py:1212 lilypond-book.py:234 midi2ly.py:1098
+#: convert-ly.py:152 etf2ly.py:1212 lilypond-book.py:234 midi2ly.py:1104
#: main.cc:186
msgid "show warranty and copyright"
msgstr ""
"file.\n"
msgstr ""
-#: etf2ly.py:1210 midi2ly.py:1069 midi2ly.py:1074 musicxml2ly.py:2859
+#: etf2ly.py:1210 midi2ly.py:1075 midi2ly.py:1080 musicxml2ly.py:2859
#: main.cc:169 main.cc:181
msgid "FILE"
msgstr ""
msgid "write snippet output files with the same base name as their source file"
msgstr ""
-#: lilypond-book.py:223 midi2ly.py:1092 musicxml2ly.py:2772
+#: lilypond-book.py:223 midi2ly.py:1098 musicxml2ly.py:2772
msgid "be verbose"
msgstr ""
msgid "warning: "
msgstr ""
-#: midi2ly.py:92 midi2ly.py:1126
+#: midi2ly.py:92 midi2ly.py:1132
msgid "error: "
msgstr ""
msgid "Exiting... "
msgstr ""
-#: midi2ly.py:834
+#: midi2ly.py:840
msgid "found more than 5 voices on a staff, expect bad output"
msgstr ""
-#: midi2ly.py:1034
+#: midi2ly.py:1040
#, python-format
msgid "%s output to `%s'..."
msgstr ""
-#: midi2ly.py:1047
+#: midi2ly.py:1053
#, python-format
msgid "Convert %s to LilyPond input.\n"
msgstr ""
-#: midi2ly.py:1052
+#: midi2ly.py:1058
msgid "print absolute pitches"
msgstr ""
-#: midi2ly.py:1054 midi2ly.py:1082
+#: midi2ly.py:1060 midi2ly.py:1088
msgid "DUR"
msgstr ""
-#: midi2ly.py:1055
+#: midi2ly.py:1061
msgid "quantise note durations on DUR"
msgstr ""
-#: midi2ly.py:1058
+#: midi2ly.py:1064
msgid "debug printing"
msgstr ""
-#: midi2ly.py:1061
+#: midi2ly.py:1067
msgid "print explicit durations"
msgstr ""
-#: midi2ly.py:1066
+#: midi2ly.py:1072
msgid "prepend FILE to output"
msgstr ""
-#: midi2ly.py:1070
+#: midi2ly.py:1076
msgid "set key: ALT=+sharps|-flats; MINOR=1"
msgstr ""
-#: midi2ly.py:1071
+#: midi2ly.py:1077
msgid "ALT[:MINOR]"
msgstr ""
-#: midi2ly.py:1076
+#: midi2ly.py:1082
msgid "preview of first 4 bars"
msgstr ""
-#: midi2ly.py:1080
+#: midi2ly.py:1086
msgid "suppress progress messages and warnings about excess voices"
msgstr ""
-#: midi2ly.py:1081
+#: midi2ly.py:1087
msgid "quantise note starts on DUR"
msgstr ""
-#: midi2ly.py:1085
+#: midi2ly.py:1091
msgid "use s instead of r for rests"
msgstr ""
-#: midi2ly.py:1087
+#: midi2ly.py:1093
msgid "DUR*NUM/DEN"
msgstr ""
-#: midi2ly.py:1090
+#: midi2ly.py:1096
msgid "allow tuplet durations DUR*NUM/DEN"
msgstr ""
-#: midi2ly.py:1100
+#: midi2ly.py:1106
msgid "treat every text as a lyric"
msgstr ""
-#: midi2ly.py:1103
+#: midi2ly.py:1109
msgid "Examples"
msgstr ""
-#: midi2ly.py:1127
+#: midi2ly.py:1133
msgid "no files specified on command line."
msgstr ""
msgid "failed redirecting stderr to `%s'"
msgstr ""
-#: general-scheme.cc:482 output-ps.scm:48
+#: general-scheme.cc:482
msgid "Found infinity or nan in output. Substituting 0.0"
msgstr ""
msgid "%d: %s"
msgstr ""
-#: grob.cc:487
+#: grob.cc:489
#, c-format
msgid "ignored infinite %s-offset"
msgstr ""
msgid "position unknown"
msgstr ""
+#: keep-alive-together-engraver.cc:93
+#, c-format
+msgid "unknown remove-layer value `%s'"
+msgstr ""
+
#: key-engraver.cc:197
msgid "Incomplete keyAlterationOrder for key signature"
msgstr ""
msgid "unexpected case fall-through"
msgstr ""
-#: midi-control-function-performer.cc:107 staff-performer.cc:159
+#: midi-cc-announcer.cc:99
#, c-format
msgid "ignoring out-of-range value change for MIDI property `%s'"
msgstr ""
-#: midi-item.cc:92
+#: midi-item.cc:91
#, c-format
msgid "no such MIDI instrument: `%s'"
msgstr ""
-#: midi-item.cc:178
+#: midi-item.cc:177
msgid "Time signature with more than 255 beats. Truncating"
msgstr ""
msgid "%s without a cause"
msgstr ""
-#: slur-engraver.cc:322
+#: slur-engraver.cc:320
#, c-format
msgid "cannot end %s"
msgstr ""
msgid "expected to read %d characters, got %d"
msgstr ""
-#: staff-performer.cc:306
+#: staff-performer.cc:273
msgid "MIDI channel wrapped around"
msgstr ""
-#: staff-performer.cc:307
+#: staff-performer.cc:274
msgid "remapping modulo 16"
msgstr ""
msgid "not a valid duration string: ~a - ignoring"
msgstr ""
-#: define-music-types.scm:798
+#: define-music-types.scm:796
#, scheme-format
msgid "symbol expected: ~S"
msgstr ""
-#: define-music-types.scm:801
+#: define-music-types.scm:799
#, scheme-format
msgid "cannot find music object: ~S"
msgstr ""
-#: define-music-types.scm:821
+#: define-music-types.scm:819
#, scheme-format
msgid "bad make-music argument: ~S"
msgstr ""
msgid "Music unsuitable for output-def"
msgstr ""
-#: lily-library.scm:920
+#: lily-library.scm:914
msgid ""
"Find the index between @var{start} and @var{end} (an integer)\n"
"which produces the closest match to @var{target-val} if\n"
"applied to function @var{getter}."
msgstr ""
-#: lily-library.scm:1014
+#: lily-library.scm:1008
#, scheme-format
msgid "unknown unit: ~S"
msgstr ""
-#: lily-library.scm:1039
+#: lily-library.scm:1033
#, scheme-format
msgid "no \\version statement found, please add~afor future compatibility"
msgstr ""
msgid "negative replication count; ignoring"
msgstr ""
+#: modal-transforms.scm:289
+msgid "Dangling tie in \\retrograde"
+msgstr ""
+
#: music-functions.scm:319
#, scheme-format
msgid "invalid tremolo repeat count: ~a"
msgid "conflicting tag group ~a"
msgstr ""
-#: output-ps.scm:290 output-svg.scm:539
+#: output-ps.scm:271 output-svg.scm:539
#, scheme-format
msgid "unknown line-cap-style: ~S"
msgstr ""
-#: output-ps.scm:295 output-svg.scm:545
+#: output-ps.scm:276 output-svg.scm:545
#, scheme-format
msgid "unknown line-join-style: ~S"
msgstr ""
msgid "No open string for pitch ~a"
msgstr ""
-#: translation-functions.scm:442 translation-functions.scm:454
+#: translation-functions.scm:450 translation-functions.scm:462
#, scheme-format
msgid "Requested string for pitch requires negative fret: string ~a pitch ~a"
msgstr ""
-#: translation-functions.scm:445
+#: translation-functions.scm:453
msgid "Ignoring string request and recalculating."
msgstr ""
-#: translation-functions.scm:457
+#: translation-functions.scm:465
msgid "Ignoring note in tablature."
msgstr ""
-#: translation-functions.scm:482
+#: translation-functions.scm:490
#, scheme-format
msgid "No string for pitch ~a (given frets ~a)"
msgstr ""
-#: translation-functions.scm:598
+#: translation-functions.scm:606
#, scheme-format
msgid ""
"No label for fret ~a (on string ~a);\n"
interesting items.")
(remove-first ,boolean? "Remove the first staff of an orchestral
score?")
- (remove-layer ,integer? "The @code{Keep_alive_together_engraver}
-removes all @code{VerticalAxisGroup} grobs with a @code{remove-layer}
-larger than the smallest retained @code{remove-layer}. Set to
-@code{#f} to make a layer invisible to the
-@code{Keep_alive_together_engraver}, set to @code{'()} to have it not
-participate in the layering decisions.")
+ (remove-layer ,key? "When set as a positive integer, the
+@code{Keep_alive_together_engraver} removes all
+@code{VerticalAxisGroup} grobs with a @code{remove-layer} larger than
+the smallest retained @code{remove-layer}. Set to @code{#f} to make a
+layer independent of the @code{Keep_alive_together_engraver}. Set to
+@code{'()}, the layer does not participate in the layering decisions.
+The property can also be set as a symbol for common behaviors:
+@code{#'any} to keep the layer alive with any other layer in the
+group; @code{#'above} or @code{#'below} to keep the layer alive with
+the context immediately before or after it, respectively.")
(replacement-alist ,list? "Alist of strings.
The key is a string of the pattern to be replaced. The value is a
string of what should be displayed. Useful for ligatures.")
\\override MultiMeasureRest
#'spacing-pair = #'(staff-bar . staff-bar)
@end example")
- (spanner-id ,string? "An identifier to distinguish concurrent spanners.")
+ (spanner-id ,key? "An identifier to distinguish concurrent spanners.")
(springs-and-rods ,boolean? "Dummy variable for triggering
spacing routines.")
(stacking-dir ,ly:dir? "Stack objects in which direction?")
(height-limit . 2.0)
(minimum-length . 1.5)
(ratio . 0.333)
- (spanner-id . "")
(springs-and-rods . ,ly:spanner::set-spacing-rods)
(stencil . ,ly:slur::print)
(thickness . 1.1)
(line-thickness . 0.8)
(minimum-length . 1.5)
(ratio . 0.25)
- (spanner-id . "")
(springs-and-rods . ,ly:spanner::set-spacing-rods)
(stencil . ,ly:slur::print)
(thickness . 1.2)
Options are @code{'text} and @code{'hairpin}.")
(span-text ,markup? "The displayed text for dynamic text
spanners (e.g., cresc.)")
- (spanner-id ,string? "Identifier to distinguish concurrent spanners.")
+ (spanner-id ,key? "Identifier to distinguish concurrent spanners.")
(start-callback ,procedure? "Function to compute the negative length
of starting grace notes. This property can only be defined as initializer
in @file{scm/@/define-music-types.scm}.")
. ((description . "Start or end phrasing slur.
Syntax: @var{note}@code{\\(} and @var{note}@code{\\)}")
- (spanner-id . "")
(types . (post-event span-event event phrasing-slur-event))
))
. ((description . "Start or end slur.
Syntax: @var{note}@code{(} and @var{note}@code{)}")
- (spanner-id . "")
(types . (post-event span-event event slur-event))
))
(define-public (polar->rectangular radius angle-in-degrees)
"Return polar coordinates (@var{radius}, @var{angle-in-degrees})
-as rectangular coordinates @ode{(x-length . y-length)}."
-
- (let ((complex (make-polar
- radius
- (degrees->radians angle-in-degrees))))
- (cons
- (real-part complex)
- (imag-part complex))))
+as rectangular coordinates @code{(x-length . y-length)}."
+ (ly:directed angle-in-degrees radius))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; string
(define-public (retrograde-music music)
"Returns @var{music} in retrograde (reversed) order."
- ;; Copied from LSR #105 and renamed.
;; Included here to allow this module to provide a complete set of
;; common formal operations on motives, i.e transposition,
;; inversion and retrograding.
- (let* ((elements (ly:music-property music 'elements))
- (arts (ly:music-property music 'articulations))
- (reversed (reverse elements))
- (element (ly:music-property music 'element))
- (span-dir (ly:music-property music 'span-direction)))
-
- (ly:music-set-property! music 'elements reversed)
-
- (for-each retrograde-music arts)
-
- (if (ly:music? element)
- (ly:music-set-property!
- music 'element
- (retrograde-music element)))
-
- (if (ly:dir? span-dir)
- (ly:music-set-property! music 'span-direction (- span-dir)))
-
- (for-each retrograde-music reversed)
-
- music))
+ (define (reverse-span! m)
+ ;; invert direction of two-sided spanners
+ (let ((spd (ly:music-property m 'span-direction)))
+ (if (ly:dir? spd)
+ (begin
+ (set! (ly:music-property m 'span-direction) (- spd))
+ (case (ly:music-property m 'name)
+ ((CrescendoEvent)
+ (make-music 'DecrescendoEvent m))
+ ((DecrescendoEvent)
+ (make-music 'CrescendoEvent m))
+ (else m)))
+ m)))
+
+ ;; carryover is a possible list of tie events, the loop returns any
+ ;; such trailing list from the given expression
+ (define (loop m carryover)
+ (define (filter-ties! m carryover field)
+ (let ((vals (ly:music-property m field)))
+ (if (pair? vals)
+ (call-with-values
+ (lambda ()
+ (partition! (music-type-predicate
+ '(tie-event glissando-event)) vals))
+ (lambda (ties no-ties)
+ (set! (ly:music-property m field)
+ (append! (map! reverse-span! no-ties) carryover))
+ ties))
+ (begin
+ (if (pair? carryover)
+ (set! (ly:music-property m field) carryover))
+ '()))))
+
+ ;; The reversal will let some prefatory material stay in front of
+ ;; the following element. Most prominently single
+ ;; overrides/reverts/sets/unsets and applyContext. This does not
+ ;; change the position of a clef (which will generally be useless
+ ;; after retrograding) but it does not jumble the clef change
+ ;; command internals. Also, stuff like \once\override stays at
+ ;; the affected element.
+
+ (define (prefatory? m)
+ (or ((music-type-predicate
+ '(apply-context apply-output-event layout-instruction-event)) m)
+ (and
+ (music-is-of-type? m 'music-wrapper-music)
+ (prefatory? (ly:music-property m 'element)))))
+
+ (define (musiclistreverse lst)
+ (let loop ((lst lst) (res '()) (zeros '()))
+ (cond ((null? lst) (reverse! zeros res))
+ ((prefatory? (car lst))
+ (loop (cdr lst) res (cons (car lst) zeros)))
+ (else
+ (loop (cdr lst) (reverse! zeros (cons (car lst) res)) '())))))
+
+ (cond ((music-is-of-type? m 'event-chord)
+ (let* ((chord-ties
+ (append!
+ (filter-ties! m carryover 'elements)
+ ;; articulations on an event-chord do not occur
+ ;; "naturally" but are supported when user-generated
+ ;; elsewhere, so we treat them properly
+ (filter-ties! m '() 'articulations)))
+ ;; in-chord ties are converted to per-chord ties.
+ ;; This is less than optimal but pretty much the
+ ;; best we can hope to achieve with this approach.
+ (element-ties
+ (append-map!
+ (lambda (m) (filter-ties! m '() 'articulations))
+ (ly:music-property m 'elements))))
+ (append! chord-ties element-ties)))
+
+ ((music-is-of-type? m 'rhythmic-event)
+ (filter-ties! m carryover 'articulations))
+
+ ;; The following is hardly correct but tieing inside of
+ ;; <<...>> is really beyond our pay grade.
+ ((music-is-of-type? m 'simultaneous-music)
+ (append-map! (lambda (m) (loop m (ly:music-deep-copy carryover)))
+ (ly:music-property m 'elements)))
+ (else
+ (let ((elt (ly:music-property m 'element))
+ (elts (ly:music-property m 'elements)))
+ (let ((res
+ (fold loop
+ (if (ly:music? elt) (loop elt carryover) carryover)
+ elts)))
+ (if (ly:music? elt)
+ (set! (ly:music-property m 'element)
+ (reverse-span! elt)))
+ (if (pair? elts)
+ (set! (ly:music-property m 'elements)
+ (map! reverse-span! (musiclistreverse elts))))
+ (append! res (filter-ties! m '() 'articulations)))))))
+ (let ((dangling (loop music '())))
+ (for-each
+ (lambda (t) (ly:music-warning t (_ "Dangling tie in \\retrograde")))
+ dangling))
+ music)
(define-public (pitch-invert around to music)
"If @var{music} is a single pitch, inverts it about @var{around}
(scm framework-ps)
(lily))
-;;; helper functions, not part of output interface
-;;;
-
-
-;; ice-9 format uses a lot of memory
-;; using simple-format almost halves lilypond cell usage
-
-(define (str4 num)
- (if (or (nan? num) (inf? num))
- (begin
- (ly:warning (_ "Found infinity or nan in output. Substituting 0.0"))
- (if (ly:get-option 'strict-infinity-checking)
- (exit 1))
- "0.0")
- (ly:number->string num)))
-
-(define (number-pair->string4 numpair)
- (ly:format "~4l" numpair))
-
;;;
;;; Lily output interface, PostScript implementation --- cleanup and docme
;;;
(ly:warning (_ "No open string for pitch ~a")
pitch)))
;; here we handle assigned strings
- (let ((this-fret
- (calc-fret pitch string tuning))
- (handle-negative
- (ly:context-property context
- 'handleNegativeFrets
- 'recalculate)))
- (cond ((or (and (>= this-fret 0) (integer? this-fret))
+ (let* ((this-fret
+ (calc-fret pitch string tuning))
+ (possible-fret?
+ (and (>= this-fret 0)
+ (if (and
+ (ly:context-property
+ context 'supportNonIntegerFret #f)
+ (null? rest))
+ (integer? (truncate this-fret))
+ (integer? this-fret))))
+ (handle-negative
+ (ly:context-property context
+ 'handleNegativeFrets
+ 'recalculate)))
+ (cond ((or possible-fret?
(eq? handle-negative 'include))
(set-fret! pitch-entry string finger))
((eq? handle-negative 'recalculate)