1 @c -*- coding: utf-8; mode: texinfo; -*-
2 @c This file is part of lilypond.tely
4 Translation of GIT committish: d96023d8792c8af202c7cb8508010c0d3648899d
6 When revising a translation, copy the HEAD committish of the
7 version that you are working on. See TRANSLATION for details.
12 @node Interfaces for programmers
13 @chapter Interfaces for programmers
15 Fortgeschrittene Anpassungen können mithilfe der Programmiersprache
16 Scheme vorgenommen werden. Wenn Sie Scheme nicht kennen, gibt
17 es eine grundlegende Einleitung in LilyPonds
18 @rlearning{Scheme tutorial}.
22 * Programmer interfaces::
23 * Building complicated functions::
24 * Markup programmer interface::
25 * Contexts for programmers::
26 * Scheme procedures as properties::
27 * Using Scheme code instead of \tweak::
33 @section Music functions
35 Dieser Abschnitt behandelt die Erstellung von musikalischen Funktionen
36 innerhalb von LilyPond.
39 * Overview of music functions::
40 * Simple substitution functions::
41 * Paired substitution functions::
42 * Mathematics in functions::
44 * Functions without arguments::
45 * Overview of available music functions::
48 @node Overview of music functions
49 @subsection Overview of music functions
51 Es ist einfach, eine Funktion zu erstellen, die Variablen
52 im LilyPond-Code ersetzt. Die allgemeine Form derartiger
57 #(define-music-function (parser location @var{var1} @var{var2}...@var{vari}... )
58 (@var{var1-type?} @var{var2-type?}...@var{vari-type?}...)
67 @multitable @columnfractions .33 .66
68 @item @var{vari} @tab die @var{i}te Variable
69 @item @var{vari-type?} @tab die Art der @var{i}ten Variable
70 @item @var{...Noten...} @tab normaler LilyPond-Code, in dem Variablen
71 wie @code{#$var1} usw. benutzt werden.
74 Die folgenden Eingabetypen können als Variablen in einer musikalischen
75 Funktion benutzt werden. Diese Liste ist nicht vollständig -- siehe
76 auch andere Dokumentationen überScheme für weitere Variablenarten.
78 @multitable @columnfractions .33 .66
79 @headitem Eingabetyp @tab @var{vari-type?}-Notation
80 @item Ganzzahl @tab @code{integer?}
81 @item Float (Dezimalzahl) @tab @code{number?}
82 @item Zeichenkette @tab @code{string?}
83 @item Textbeschriftung @tab @code{markup?}
84 @item Musikalischer Ausdruck @tab @code{ly:music?}
85 @item Ein Variablenpaar @tab @code{pair?}
88 Die Argumente @code{parser} und @code{location} sind zwingend erforderlich
89 und werden in einigen fortgeschrittenen Situationen eingesetzt. Das
90 Argument @code{parser} wird benutzt, um auf den Wert einer weiteren
91 LilyPond-Variable zuzugreifen. Das Argument @code{location} wird
92 benutzt, um den @qq{Ursprung} des musikalischen Ausdrucks zu definieren, der von
93 der musikalischen Funktion erzeugt wird. Das hilft, wenn ein
94 Syntaxfehler auftaucht: in solchen Fällen kann LilyPond mitteilen,
95 an welcher Stelle in der Eingabedatei sich der Fehler befindet.
98 @node Simple substitution functions
99 @subsection Simple substitution functions
101 Hier ist ein einfaches Beispiel:
103 @lilypond[quote,verbatim,ragged-right]
104 padText = #(define-music-function (parser location padding) (number?)
106 \once \override TextScript #'padding = #$padding
114 c4^"piu mosso" fis a g
118 Musikalische Ausdrücke können auch ersetzt werden:
120 @lilypond[quote,verbatim,ragged-right]
121 custosNote = #(define-music-function (parser location note)
124 \once \override Voice.NoteHead #'stencil =
125 #ly:text-interface::print
126 \once \override Voice.NoteHead #'text =
127 \markup \musicglyph #"custodes.mensural.u0"
128 \once \override Voice.Stem #'stencil = ##f
132 { c' d' e' f' \custosNote g' }
135 Mehrere Variablen können benutzt werden:
137 @lilypond[quote,verbatim,ragged-right]
138 tempoPadded = #(define-music-function (parser location padding tempotext)
141 \once \override Score.MetronomeMark #'padding = $padding
142 \tempo \markup { \bold $tempotext }
146 \tempo \markup { "Low tempo" }
148 \tempoPadded #4.0 #"High tempo"
154 @node Paired substitution functions
155 @subsection Paired substitution functions
157 Einige @code{\override}-Befehle benötigen ein Zahlenpaar
158 (als @code{cons}-Zelle in Scheme bezeichnet). Um beide Zahlen
159 einer Funktion zuzuweisen, kann entweder die Variable @code{pair?}
160 benutzt werden oder die @code{cons} in die musikalische Funktion
166 #(define-music-function (parser location beg-end)
169 \once \override Beam #'positions = #$beg-end
173 \manualBeam #'(3 . 6) c8 d e f
181 @lilypond[quote,verbatim,ragged-right]
183 #(define-music-function (parser location beg end)
186 \once \override Beam #'positions = #(cons $beg $end)
190 \manualBeam #3 #6 c8 d e f
195 @node Mathematics in functions
196 @subsection Mathematics in functions
198 Musikalische Funktionen können neben einfachen Ersetzungen
199 auch Scheme-Programmcode enthalten:
201 @lilypond[quote,verbatim,ragged-right]
202 AltOn = #(define-music-function (parser location mag) (number?)
203 #{ \override Stem #'length = #$(* 7.0 mag)
204 \override NoteHead #'font-size =
205 #$(inexact->exact (* (/ 6.0 (log 2.0)) (log mag))) #})
208 \revert Stem #'length
209 \revert NoteHead #'font-size
212 { c'2 \AltOn #0.5 c'4 c'
213 \AltOn #1.5 c' c' \AltOff c'2 }
217 Dieses Beispiel kann auch umformuliert werden, um musikalische Ausdrücke
220 @lilypond[quote,verbatim,ragged-right]
221 withAlt = #(define-music-function (parser location mag music) (number? ly:music?)
222 #{ \override Stem #'length = #$(* 7.0 mag)
223 \override NoteHead #'font-size =
224 #$(inexact->exact (* (/ 6.0 (log 2.0)) (log mag)))
226 \revert Stem #'length
227 \revert NoteHead #'font-size #})
229 { c'2 \withAlt #0.5 {c'4 c'}
230 \withAlt #1.5 {c' c'} c'2 }
235 @subsection Void functions
237 Eine musikalische Funktion muss einen musikalischen Ausdruck
238 ausgeben, aber in manchen Fällen müssen Funktionen erstellt werden,
239 die keine Notation enthalten (wie etwa eine Funktion, mit der
240 man @qq{Point and Click} ausschalten kann). Um das vornehmen zu
241 können, wird ein @code{leere}r musikalischer Ausdruck ausgegeben.
243 Das ist der Grund, warum die Form, die ausgegeben wird,
244 @code{(make-music ...)} heißt. Wird die Eigenschaft
245 @code{'void} (engl. für @qq{leer}) auf @code{#t} gesetzt, wird der
246 Parser angewiesen, den ausgegebenen musikalischen Ausdruck zu ignorieren.
247 Der maßgebliche Teil der @code{'void}-Funktion ist also die Verarbeitung,
248 die die Funktion vornimmt, nicht der musikalische Ausdruck, der ausgegeben
253 #(define-music-function (parser location) ()
254 (ly:set-option 'point-and-click #f)
255 (make-music 'SequentialMusic 'void #t))
257 \noPointAndClick % disable point and click
261 @node Functions without arguments
262 @subsection Functions without arguments
264 In den meisten Fällen sollten Funktionen ohne Argumente mit einer
265 Variable notiert werden:
268 dolce = \markup@{ \italic \bold dolce @}
271 In einigen wenigen Fällen kann es aber auch sinnvoll sein, eine
272 musikalische Funktion ohne Argumente zu erstellen:
276 #(define-music-function (parser location) ()
277 (if (eq? #t (ly:get-option 'display-bar-numbers))
278 #@{ \once \override Score.BarNumber #'break-visibility = ##f #@}
282 Damit auch wirklich Taktzahlen angezeigt werden, wo die
283 Funktion eingesetzt wurde, muss @command{lilypond} mit
287 lilypond -d display-bar-numbers Dateiname.ly
294 @node Overview of available music functions
295 @subsection Overview of available music functions
297 @c fixme ; this should be move somewhere else?
298 Die folgenden Befehle sind musikalische Funktionen:
300 @include identifiers.tely
304 @node Programmer interfaces
305 @section Programmer interfaces
307 Dieser Abschnitt zeigt, wie LilyPond und
308 Scheme gemischt werden können.
311 * Input variables and Scheme::
312 * Internal music representation::
316 @node Input variables and Scheme
317 @subsection Input variables and Scheme
319 Das Eingabeformat unterstützt die Notation von Variablen: im
320 folgenden Beispiel wird ein musikalischer Ausdruck einer Variable
321 mit der Bezeichnung @code{traLaLa} zugewiesen:
324 traLaLa = @{ c'4 d'4 @}
327 Der Geltungsbereich von Variablen ist beschränkt: im folgenden
328 Beispiel enthält die @code{\layout}-Umgebung auch eine
329 @code{traLaLa}-vVariable, die unabhängig von der äußeren
330 @code{\traLaLa}-Variable ist:
333 traLaLa = @{ c'4 d'4 @}
334 \layout @{ traLaLa = 1.0 @}
337 Grundsätzlich ist jede Eingabedatei ein Geltungsbereich, und
338 alle @code{\header}-, @code{\midi}- und @code{\layout}-Umgebungen
339 sind Geltungsbereiche, die unterhalb des globalen Geltungsbereiches
342 Sowohl Variablen als auch Geltungsbereiche sind in Form des
343 GUILE-Modulsystems implementiert. Ein anonymes Scheme-Modul
344 wird an jeden Geltunsbereich angehängt. Eine Zuweisung der form
347 traLaLa = @{ c'4 d'4 @}
351 wird intern in die Scheme-Definition
354 (define traLaLa @var{Scheme-Wert von `@code{... }'})
360 Das bedeutet, dass Eingabe- und Scheme-Variablen frei vermischt
361 werden können. Im nächsten Beispiel wird ein Notenfragment in
362 der Variable @code{traLaLa} gespeichert und mithilfe von Schme
363 dupliziert. Das Ergebnis wird in eine @code{\score}-Umgebung
364 mit der zweiten Variable @code{twice} integriert:
367 traLaLa = { c'4 d'4 }
369 %% dummy action to deal with parser lookahead
370 #(display "this needs to be here, sorry!")
372 #(define newLa (map ly:music-deep-copy
373 (list traLaLa traLaLa)))
375 (make-sequential-music newLa))
380 In diesem Beispiel geschieht die Zuweisung, nachdem der Parser
381 festgestellt hat, dass nichts interessantes mehr nach
382 @code{traLaLa = @{ ... @}} vorkommt. Ohne die Pseudovariable
383 in dem Beispiel würde die @code{newLa}-Devinition ausgeführt
384 werden, bevor @code{traLaLa} definiert ist, was zu einem
385 Syntax-Fehler führen würde.
387 Das obige Beispiel zeigt, wie man musikalische Ausdrücke
388 von der Eingabe in den Scheme-Interpretierer @qq{exportieren}
389 kann. Es geht auch in die andere Richtung. Indem man einen
390 Scheme-Wert in die Funktion @code{ly:export} einpackt, wird
391 der Scheme-Wert interpretiert als ob er in LilyPond-Syntax
392 notiert worden wäre. Anstatt @code{\twice} zu definieren,
393 hätte man also auch schreiben können:
397 @{ #(ly:export (make-sequential-music (list newLa))) @}
400 Scheme-Code wird sofort ausgewertet, wenn der Parser darauf
401 stößt. Um Scheme-Code in einem Makro zu definieren (das dann
402 erst später aufgerufen werden soll), müssen leere Funktionen
403 benutzt werden (siehe @ref{Void functions}) oder das Folgende:
407 (ly:set-option 'point-and-click #f))
416 Scheme- und LilyPond-Variablen können im LilyPond-Modus mit der
417 @code{--safe}-Option nicht vermischt werden.
420 @node Internal music representation
421 @subsection Internal music representation
423 Wenn ein musikalischer Ausdruck ausgewertet wird, wird er in eine
424 Anzahl von musikalischen Scheme-Objekten konvertiert. Die Eigenschaft, die ein
425 musikalisches Objekt definiert, ist, dass es Zeit einnimmt. Zeit ist
426 eine rationale Zahl, die die Länge eines Stückes in ganzen Noten
429 Ein musikalisches Objekt hat drei Typusarten:
432 musikalische Bezeichnung: Jeder musikalische Ausdruck hat eine Bezeichnung.
433 Eine Note beispielsweise führt zu einem @rinternals{NoteEvent} und
434 @code{\simultaneous} führt zu @rinternals{SimultaneousMusic}. Eine Liste
435 aller möglichen Ausdrücke findet sich in der Referenz der Interna, unter
436 @rinternals{Music expressions}.
439 @q{Typ} oder Schnittstelle: Jede musikalische Bezeichnung hat mehrere
440 @qq{Typen} oder Schnittstellten, beispielsweise ist eine Note ein
441 @code{event}, ober sie ist auch ein @code{note-event}, ein
442 @code{rhythmic-event} und ein @code{melodic-event}. Alle diese
443 Notationsklassen finden sich in der Referenz der Interna unter
444 @rinternals{Music classes}.
447 C++-Objekt: Jedes musikalische Objekt wird von einem Objekt der
448 C++-Klasse @code{Music} repräsentiert.
451 Die eigentlich Information eines musikalischen Ausdrucks ist in
452 Eigenschaften gespeichert. Ein @rinternals{NoteEvent} hat zum
453 Beispiel @code{pitch}- und @code{duration}-Eigenschaften, die
454 die Tonhöhe und die Dauer dieser Note speichern. Eine Liste aller
455 verfügbaren Eigenschaften findet sich in der Referenz der Interna unter
456 @rinternals{Music properties}.
458 Ein zusammengesetzter musikalischer Ausdruck ist ein musikalisches
459 Objekt, das andere Objekte in seinen Eigenschaften enthält. Eine Liste
460 der Objekte kann in der @code{elements}-Eigenschaft eines
461 musikalischen Objektes gespeichert werden, oder ein einziges
462 @qq{Kind}-Objekt in der @code{element}-Eigenschaft. Sa hat etwa
463 @rinternals{SequentialMusic} seine @qq{Kinder} in @code{elements},
464 und @rinternals{GraceMusic} hat sein einziges Argument in
465 @code{element}. Der Hauptteil einer Wiederholung wird in der
466 @code{element}-Eigenschaft von @rinternals{RepeatedMusic} gespeichert,
467 und die Alternativen in @code{elements}.
471 @node Building complicated functions
472 @section Building complicated functions
474 Dieser Abschnitt zeigt, wie man Information zusammensucht,
475 um komplizierte musikalische Funktionen zu erstellen.
478 * Displaying music expressions::
480 * Doubling a note with slurs (example)::
481 * Adding articulation to notes (example)::
485 @node Displaying music expressions
486 @subsection Displaying music expressions
488 @cindex interne Speicherung
489 @cindex Musikausdrücke anzeigen
490 @cindex Anzeigen von Musikausdrücken
492 @funindex displayMusic
493 @funindex \displayMusic
495 Wenn man eine musikalische Funktion erstellt, ist es oft
496 hilfreich sich anzuschauen, wie musikalische Funktionen
497 intern gespeichert werden. Das kann mit der Funktion
498 @code{\displayMusic} erreicht werden:
502 \displayMusic @{ c'4\f @}
519 (ly:make-duration 2 0 1 1)
521 (ly:make-pitch 0 0 0))
523 'AbsoluteDynamicEvent
528 Normalerweise gibt LilyPond diese Ausgabe auf der Konsole mit
529 allen anderen Nachrichten aus. Um die wichtigen Nachrichten
530 in einer Datei zu speichern, kann die Ausgabe in eine Datei
534 lilypond file.ly >display.txt
537 Mit etwas Umformatierung ist die gleiche Information sehr viel
541 (make-music 'SequentialMusic
542 'elements (list (make-music 'EventChord
543 'elements (list (make-music 'NoteEvent
544 'duration (ly:make-duration 2 0 1 1)
545 'pitch (ly:make-pitch 0 0 0))
546 (make-music 'AbsoluteDynamicEvent
550 Eine musikalische @code{@{ ... @}}-Sequenz hat die Bezeichnung
551 @code{SequentialMusic} und ihre inneren Ausdrücke werden als
552 Liste in seiner @code{'elements}-Eigenschaft gespeichert. Eine
553 Note ist als als ein @code{EventChord}-Ausdruck dargestellt,
554 der ein @code{NoteEvent}-Objekt (welches Dauer und
555 Tonhöhe speichert) und zusätzliche Information enthält (in
556 diesem Fall ein @code{AbsoluteDynamicEvent} mit einer
557 @code{"f"}-Text-Eigenschaft.
560 @node Music properties
561 @subsection Music properties
563 Das @code{NoteEvent}-Objekt ist das erste Objekt der
564 @code{'elements}-Eigenschaft von @code{someNote}.
568 \displayMusic \someNote
576 (ly:make-duration 2 0 1 1)
578 (ly:make-pitch 0 0 0))))
581 Die @code{display-scheme-music}-Funktion ist die Funktion, die von
582 @code{\displayMusic} eingesetzt wird, um die Scheme-Repräsentation
583 eines musikalischen Ausdrucks anzuzeigen.
586 #(display-scheme-music (first (ly:music-property someNote 'elements)))
591 (ly:make-duration 2 0 1 1)
593 (ly:make-pitch 0 0 0))
596 Danach wird die Tonhöhe der Note von der @code{'pitch}-Eigenschaft
597 des @code{NoteEvent}-Objektes gelesen:
600 #(display-scheme-music
601 (ly:music-property (first (ly:music-property someNote 'elements))
604 (ly:make-pitch 0 0 0)
607 Die Tonhöhe einer Note kann geändert werden, indem man diese
608 @code{'pitch}-Eigenschaft umdefiniert:
610 @funindex \displayLilyMusic
611 @funindex displayLilyMusic
614 #(set! (ly:music-property (first (ly:music-property someNote 'elements))
616 (ly:make-pitch 0 1 0)) ;; Die Tonhöhen auf d' verändern.
617 \displayLilyMusic \someNote
623 @node Doubling a note with slurs (example)
624 @subsection Doubling a note with slurs (example)
626 In diesem Abschnitt soll gezeigt, werden, wie man eine
627 Funktion erstellt, die eine Eingabe wie @code{a}
628 nach @code{a( a)} umdefiniert. Dazu wird zuerst die
629 interne Repräsentation der Musik betrachtet, die
630 das Endergebnis darstellt:
633 \displayMusic@{ a'( a') @}
644 (ly:make-duration 2 0 1 1)
646 (ly:make-pitch 0 5 0))
657 (ly:make-duration 2 0 1 1)
659 (ly:make-pitch 0 5 0))
666 Eine schlechte Nachricht ist, dass die
667 @code{SlurEvent}-Ausdrücke @qq{innerhalb}
668 der Noten (bzw. innerhalb der
669 @code{EventChord}-Ausdrücke) hinzugefügt werden müssen.
671 Jetzt folgt eine Betrachtung der Eingabe:
683 (ly:make-duration 2 0 1 1)
685 (ly:make-pitch 0 5 0))))))
688 In der gewünschten Funktion muss also dieser Ausdruck
689 kopiert werden (sodass zwei Noten vorhanden sind, die
690 eine Sequenz bilden), dann müssen @code{SlurEvent}
691 zu der @code{'elements}-Eigenschaft jeder Noten hinzugefügt
692 werden, und schließlich muss eine @code{SequentialMusic}
693 mit den beiden @code{EventChords} erstellt werden.
696 doubleSlur = #(define-music-function (parser location note) (ly:music?)
697 "Return: @{ note ( note ) @}.
698 `note' is supposed to be an EventChord."
699 (let ((note2 (ly:music-deep-copy note)))
700 (set! (ly:music-property note 'elements)
701 (cons (make-music 'SlurEvent 'span-direction -1)
702 (ly:music-property note 'elements)))
703 (set! (ly:music-property note2 'elements)
704 (cons (make-music 'SlurEvent 'span-direction 1)
705 (ly:music-property note2 'elements)))
706 (make-music 'SequentialMusic 'elements (list note note2))))
710 @node Adding articulation to notes (example)
711 @subsection Adding articulation to notes (example)
713 Am einfachsten können Artikulationszeichen zu Noten
714 hinzugefügt werden, indem man zwei musikalische Funktionen
715 in einen Kontext einfügt, wie erklärt in
716 @ref{Creating contexts}. Hier soll jetzt eine musikalische
717 Funktion entwickelt werden, die das vornimmt.
719 Eine @code{$variable} innerhalb von @code{#@{...#@}} ist das
720 gleiche wie die normale Befehlsform @code{\variable} in
721 üblicher LilyPond-Notation. Es ist bekannt dass
728 in LilyPond nicht funktioniert. Das Problem könnte vermieden
729 werden, indem das Artikulationszeichen an eine Pseudonote
733 @{ << \music s1*0-.-> @}
737 aber in diesem Beispiel soll gezeigt werden, wie man das in
738 Scheme vornimmt. Zunächst wird die Eingabe und die gewünschte
751 (ly:make-duration 2 0 1 1)
753 (ly:make-pitch -1 0 0))))
764 (ly:make-duration 2 0 1 1)
766 (ly:make-pitch -1 0 0))
773 Dabei ist zu sehen, dass eine Note (@code{c4}) als @code{EventChord}
774 repräsentiert ist, mit einem @code{NoteEvent}-Ausdruck in ihrer
775 Elementenliste. Um eine Marcato-Artikulation hinzuzufügen, muss
776 ein @code{ArticulationEvent}-Ausdrcuk zu der Elementeigenschaft
777 des @code{EventChord}-Ausdrucks hinzugefügt werden.
779 Um diese Funktion zu bauen, wird folgerndermaßen begonnen:
782 (define (add-marcato event-chord)
783 "Add a marcato ArticulationEvent to the elements of `event-chord',
784 which is supposed to be an EventChord expression."
785 (let ((result-event-chord (ly:music-deep-copy event-chord)))
786 (set! (ly:music-property result-event-chord 'elements)
787 (cons (make-music 'ArticulationEvent
788 'articulation-type "marcato")
789 (ly:music-property result-event-chord 'elements)))
793 Die erste Zeile definiert eine Funktion in Scheme: Die Bezeichnung
794 der Funktion ist @code{add-marcato} und sie hat eine Variable
795 mit der Bezeichnung @code{event-chord}. In Scheme geht der Typ
796 einer Variable oft direkt aus der Bezeichnung hervor (das ist auch
797 eine gute Methode für andere Programmiersprachen).
804 ist eine (englische) Beschreibung, was diese Funktion tut. Sie ist
805 nicht unbedingt notwendig, aber genauso wie klare Variablen-Bezeichnungen
806 ist auch das eine gute Methode.
809 (let ((result-event-chord (ly:music-deep-copy event-chord)))
812 @code{let} wird benutzt, um die lokalen Variablen zu definieren. Hier
813 wird eine lokale Variable benutzt: @code{result-event-chord}. Sie erhält
814 den Wert @code{(ly:music-deep-copy event-chord)}. @code{ly:music-deep-copy}
815 ist eine LilyPond-spezifische Funktion, die wie alle Funktionen mit dem
816 Präfix @code{ly:} versehen ist. Sie wird benutzt, um eine Kopie eines
817 musikalischen Ausdrucks anzufertigen. Hier wird @code{event-chord}
818 (der Parameter der Funktion) kopiert. Die Funktion soll ja nur ein
819 Artikulationszeichen an einen @code{EventChord} gehängt werden, deshalb ist es besser,
820 den @code{EventChord}, der als Argument gegeben wurde, nicht zu
821 verändern, weil er woanders benutzt werden könnte.
823 Jetzt gibt es @code{result-event-chord}, wobei es sich um einen
824 @code{NoteEventChord}-Ausdruck handelt, welcher gleichzeigt eine Kopie
825 von @code{event-chord} ist. Das Makro wird seiner Eigenschaftsliste
829 (set! place new-value)
832 Was in diesem Fall @qq{gesetzt} werden soll (@qq{place}) ist die
833 @q{elements}-Eigenschaft des @code{result-event-chord}-Ausdrucks.
836 (ly:music-property result-event-chord 'elements)
839 @code{ly:music-property} ist die Funktion, mit der musikalische
840 Eigenschaften erreicht werden können (die @code{'elements},
841 @code{'duration}, @code{'pitch} usw., die in der Ausgabe von
842 @code{\displayMusic} weiter oben angezeigt werden). Der neue
843 Wert ist, was ehemals die Elemtneigenschaft war, mit einem
844 zusätzlichen Element: dem @code{ArticulationEvent}-Ausdruck,
845 der aus der Ausgabe von
846 @code{\displayMusic} kopiert werden kann:
849 (cons (make-music 'ArticulationEvent
850 'articulation-type "marcato")
851 (ly:music-property result-event-chord 'elements))
854 @code{cons} wird benutzt, um ein Element zu einer Liste hinzuzufügen,
855 ohne dass die originale Liste verändert wird. Das ist es, was die
856 Funktion tun soll: die gleiche Liste, aber mit dem neuen
857 @code{ArticulationEvent}-Ausdruck. Die Reihenfolge innerhalb
858 der Elementeeigenschaft ist hier nicht relevant.
860 Wenn schließlich die Marcato-Artikulation zu der entsprechenden
861 @code{elements}-Eigenschaft hinzuzugefügt ist, kann
862 @code{result-event-chord} ausgegeben werden, darum die letzte Zeile
865 Jetzt wird die @code{add-marcato}-Funktion in eine musikalische
866 Funktion umgewandelt:
869 addMarcato = #(define-music-function (parser location event-chord)
871 "Add a marcato ArticulationEvent to the elements of `event-chord',
872 which is supposed to be an EventChord expression."
873 (let ((result-event-chord (ly:music-deep-copy event-chord)))
874 (set! (ly:music-property result-event-chord 'elements)
875 (cons (make-music 'ArticulationEvent
876 'articulation-type "marcato")
877 (ly:music-property result-event-chord 'elements)))
881 Eine Überprüfung, dass die Funktion richtig arbeitet, geschieht
885 \displayMusic \addMarcato c4
889 @node Markup programmer interface
890 @section Markup programmer interface
892 Textbeschriftungselemente sind als besondere Scheme-Funktionen
893 definiert, die ein Stencil-Objekt erstellen, dem eine Anzahl
894 an Argumenten übergeben wird.
897 * Markup construction in Scheme::
898 * How markups work internally::
899 * New markup command definition::
900 * New markup list command definition::
904 @node Markup construction in Scheme
905 @subsection Markup construction in Scheme
907 @cindex Textbeschriftungsbefehle, definieren
908 @cindex Textbeschriftung, eigene Befehle
909 @cindex eigene Befehle, Textbeschriftung
910 @cindex markup, eigene Befehle
911 @cindex Befehle definieren, Textbeschriftung
913 Das @code{markup}-(Textbeschriftungs)Makro erstellt Textbeschriftungs-Ausdrücke
914 in Scheme, wobei eine LilyPond-artige Syntax benutzt wird. Beispielsweise
918 (markup #:column (#:line (#:bold #:italic "hello" #:raise 0.4 "world")
919 #:larger #:line ("foo" "bar" "baz")))
926 \markup \column @{ \line @{ \bold \italic "hello" \raise #0.4 "world" @}
927 \larger \line @{ foo bar baz @} @}
931 Dieses Beispiel zeigt die hauptsächlichen Übersetzungsregeln
932 zwischen normaler Textbeschriftungssyntax von LilyPond und der
933 Textbeschriftungssyntax in Scheme.
936 @multitable @columnfractions .3 .3
937 @item @b{LilyPond} @tab @b{Scheme}
938 @item @code{\markup Text1} @tab @code{(markup Text1)}
939 @item @code{\markup @{ Text1 Text2 ... @}} @tab
940 @code{(markup Text1 Text2 ... )}
941 @item @code{\Befehl} @tab @code{#:Befehl}
942 @item @code{\Variable} @tab @code{Variable}
943 @item @code{\center-column @{ ... @}} @tab @code{#:center-column ( ... )}
944 @item @code{Zeichenkette} @tab @code{"Zeichenkette"}
945 @item @code{#scheme-arg} @tab @code{scheme-arg}
949 Die gesamte Scheme-Sprache ist innerhalb des @code{markup}-Makros
950 zugänglich. Man kann also beispielsweise Funktionen innerhalb
951 eines @code{markup} aufrufen, um Zeichenketten zu manipulieren.
952 Das ist nützlich, wenn neue Beschriftungsbefehle definiert werden
954 @ref{New markup command definition}).
959 Das Beschriftungslistenargument von Befehlen wie @code{#:line},
960 @code{#:center} und @code{#:column} kann keine Variable oder
961 das Resultat eines Funktionsaufrufen sein.
964 (markup #:line (Funktion-die-Textbeschriftung-ausgibt))
968 ist ungültig. Man sollte anstatt dessen die Funktionen
969 @code{make-line-markup}, @code{make-center-markup} oder
970 @code{make-column-markup} benutzen:
973 (markup (make-line-markup (Funktion-die-Textbeschriftung-ausgibt)))
977 @node How markups work internally
978 @subsection How markups work internally
980 In einer Textbeschriftung wie
983 \raise #0.5 "Textbeispiel"
987 ist @code{\raise} unter der Haube durch die @code{raise-markup}-Funktion
988 repräsentiert. Der Beschriftungsausdruck wird gespeichert als
991 (list raise-markup 0.5 (list simple-markup "Textbeispiel"))
994 Wenn die Beschriftung in druckbare Objekte (Stencils) umgewandelt ist,
995 wir die @code{raise-markup}-Funktion folgendermaßen aufgerufen:
1000 @var{Liste der Eigenschafts-alists}
1002 @var{die "Textbeispiel"-Beschriftung})
1005 Die @code{raise-markup}-Funktion erstellt zunächt den Stencil für die
1006 @code{Textbeispiel}-Beschriftung und verschiebt dann diesen Stencil
1007 um 0.5 Notenlinienzwischenräume nach oben. Das ist ein einfaches
1008 Beispiel. Weitere, kompliziertere Beispiele finden sich nachfolgend
1009 in diesem Abschnitt und in der Datei
1010 @file{scm/@/define@/-markup@/-commands@/.scm}.
1013 @node New markup command definition
1014 @subsection New markup command definition
1016 Neue Textbeschriftungsbefehle können mit dem
1017 @code{define-markup-command}-Scheme-Makro definiert werden.
1020 (define-markup-command (@var{befehl-bezeichnung} @var{layout} @var{props} @var{arg1} @var{arg2} ...)
1021 (@var{arg1-type?} @var{arg2-type?} ...)
1029 @var{i}te Befehlsargument
1031 eine Eigenschaft für das @var{i}te Argument
1033 die @q{layout}-Definition
1035 eine Liste an alists, in der alle aktiven Eigenschaften enthalten sind
1038 Als einfaches Beispiel soll gezeigt werden, wie man einen
1039 @code{\smallcaps}-Befehl hinzufügen kann, der die Kapitälchen
1040 für die Schriftzeichen auswählt. Normalerweise würde man Kapitälchen
1041 folgendermaßen auswählen:
1044 \markup @{ \override #'(font-shape . caps) Text-in-Kapitälchen @}
1048 Damit wird die Kapitälchenschriftart ausgewählt, indem die
1049 @code{font-shape}-Eigesnchaft auf @code{#'caps} gesetzt wird,
1050 während @code{Text-in-caps} interpretiert wird.
1052 Damit diese Funkion als @code{\smallcaps}-Befehl zur Verfügung
1053 gestellt werden kann, muss eine Funktion mit @code{define-markup-command}
1054 definiert werden. Der Befehl braucht ein Argument vom Typ @code{markup}.
1055 Darum sollte der Beginn der Funktion lauten:
1058 (define-markup-command (smallcaps layout props argument) (markup?)
1063 Was jetzt folgt, ist der eigentliche Inhalt des Befehls: das
1064 @code{argument} soll als Beschriftung (markup) interpretiert werden,
1068 (interpret-markup layout @dots{} argument)
1072 Diese Interpretation sollte @code{'(font-shape . caps)} zu den
1073 aktiven Eigenschaften hinzufügen, weshalb wir das Folgende anstelle
1074 der @dots{} in dem Beispiel einfügen:
1077 (cons (list '(font-shape . caps) ) props)
1081 Die Variable @code{props} ist eine Liste an alists, und mit @code{cons}
1082 wird ihr eine zusätzliche Einstellung hinzugefügt.
1084 Man könnte sich auch vorstellen, dass ein Rezitativ einer Oper
1085 gesetzt werden soll, und ein Befehl wäre sehr bequem, mit dem
1086 man die Namen der Charaktere auf eine eigene Art darstellen könnte.
1087 Namen sollen in Kapitälchen gesetzt werden und etwas nach links und
1088 oben verschoben werden. Man kann also einen @code{\character}-Befehl
1089 definieren, der die nötige Verschiebung berücksichtigt und
1090 den neuen @code{\smallcaps}-Befehl einsetzt:
1093 #(define-markup-command (character layout props name) (string?)
1094 "Print the character name in small caps, translated to the left and
1095 top. Syntax: \\character #\"name\""
1096 (interpret-markup layout props
1097 (markup #:hspace 0 #:translate (cons -3 1) #:smallcaps name)))
1100 Hier ist eine Komplikation, die erklärt werden muss: Text über oder
1101 unter dem Notensystem wird vertikal verschoben um in einem bestimmten
1102 Abstand von dem System und den Noten zu sein (das wird als @qq{padding}
1103 bezeichnet). Um sicherzugehen, dass dieser Mechanismus nicht die
1104 vertikale Verschiebung von @code{#:translate} annulliert, wird
1105 die leere Zeichenkette (@code{#:hspace 0}) vor den zu verschiebenden
1106 Text gesetzt. Das @code{#:hspace 0} wird jetzt also über die Noten
1107 gesetzt und @code{name} dann relativ zu der leeren Zeichenkette
1108 verschoben. Im Endeffekt wird der Text nach links oben verschoben.
1110 Das Resultat sieht folgendermaßen aus:
1114 c''^\markup \character #"Cleopatra"
1115 e'^\markup \character #"Giulio Cesare"
1119 @lilypond[quote,ragged-right]
1120 #(define-markup-command (smallcaps layout props str) (string?)
1121 "Print the string argument in small caps. Syntax: \\smallcaps #\"string\""
1122 (interpret-markup layout props
1125 (if (= (string-length s) 0)
1127 (markup #:large (string-upcase (substring s 0 1))
1128 #:translate (cons -0.6 0)
1129 #:tiny (string-upcase (substring s 1)))))
1130 (string-split str #\Space)))))
1132 #(define-markup-command (character layout props name) (string?)
1133 "Print the character name in small caps, translated to the left and
1134 top. Syntax: \\character #\"name\""
1135 (interpret-markup layout props
1136 (markup #:hspace 0 #:translate (cons -3 1) #:smallcaps name)))
1139 c''^\markup \character #"Cleopatra" c'' c'' c''
1140 e'^\markup \character #"Giulio Cesare" e' e' e'
1144 In diesen Befehlen wurden Kapitälchen eingesetzt, aber es kann
1145 vorkommen, dass die Schriftart keine Kapitälchen zur Verfügung
1146 stellt. In diesem Fall können die Kapitälchen nachempfunden
1147 werden, indem man Großbuchstaben setzt, deren Anfangsbuchstabe
1148 etwas größer gesetzt wird:
1151 #(define-markup-command (smallcaps layout props str) (string?)
1152 "Print the string argument in small caps."
1153 (interpret-markup layout props
1156 (if (= (string-length s) 0)
1158 (markup #:large (string-upcase (substring s 0 1))
1159 #:translate (cons -0.6 0)
1160 #:tiny (string-upcase (substring s 1)))))
1161 (string-split str #\Space)))))
1164 Der @code{smallcaps}-Befehl spaltet die Argumente zuerst in
1165 Einzelstücke auf, die von Leerzeichen getrennt sind
1166 (@code{(string-split str #\Space)}); für jedes Einzelstück
1167 wird dann eine Beschriftung aufgebaut, deren erster Buchstabe
1168 vergrößert wird und als Versalbuchstabe gesetzt wird
1169 (@code{#:large (string-upcase (substring s 0 1))}), und eine
1170 zweite Versalbuchstaben gesetzt werden
1171 (@code{#:tiny (string-upcase (substring s 1))}). Wenn
1172 LilyPond ein Leerzeichen zwischen Beschriftungen einer Zeile
1173 entdeckt, wird die zweite Beschriftung nach links verschoben
1174 (@code{#:translate (cons -0.6 0) ...}). Dann werden die
1175 Beschriftungen für jedes Einzelstück in eine Zeile gesetzt
1176 @code{(make-line-markup ...)}. Schließlich wird die resultierende
1177 Beschriftung an die @code{interpret-markup}-Funktion zusammen
1178 mit den Argumenten @code{layout} und @code{props} weitergereicht.
1180 Achtung: ist gibt keinen internen Befehl @code{\smallCaps}, der
1181 benutzt werden kann, um Text in Kapitälchen zu setzen. Siehe auch
1182 @ref{Text markup commands}.
1186 Im Moment sind die möglichen Kombinationen von Argumenten (nach den
1187 Standardargumenten @var{layout} und @var{props}), die mit
1188 @code{define-markup-command} definiert werden, wie folgt
1192 @item (kein Argument)
1195 @itemx @var{markup markup}
1197 @itemx @var{scm markup}
1198 @itemx @var{scm scm}
1199 @itemx @var{scm scm markup}
1200 @itemx @var{scm scm markup markup}
1201 @itemx @var{scm markup markup}
1202 @itemx @var{scm scm scm}
1206 Hier stellt @var{scm} native Scheme-Datentypen dar wie
1207 @q{number} oder @q{string}.
1209 Es ist beispielsweise nicht möglich, einen Beschriftungsbefehl
1210 @code{foo} mit vier Argumenten in folgender Weise zu nutzen:
1213 #(define-markup-command (foo layout props
1214 num1 str1 num2 str2)
1215 (number? string? number? string?)
1220 Wenn es folgendermaßen eingesetzt wird:
1223 \markup \foo #1 #"bar" #2 #"baz"
1226 @cindex Scheme signature
1227 @cindex Signatur, Scheme
1229 beschwert sich @command{lilypond}, dass @code{foo} wegen einer ungekannten
1230 Scheme Signatur nicht analysiert werden kann.
1233 @node New markup list command definition
1234 @subsection New markup list command definition
1236 Beschriftungslistenbefehle können mit dem Scheme-Makro
1237 @code{define-markup-list-command} definiert werden, welches
1238 sich ähnlich verhält wie das
1239 @code{define-markup-command}-Makro, das schon beschrieben
1240 wurde in @ref{New markup command definition}. Ein Unterschied
1241 ist, dass bei diesem Listen-Makro eine ganze Liste an
1242 Stecils ausgegeben wird.
1244 Im folgenden Beispiel wird ein @code{\paragraph}-Beschriftungslistenbefehl
1245 definiert, welcher eine Liste von Zeilen im Blocksatz ausgibt, von
1246 denen die erste Zeile eingerückt ist. Der Einzug wird aus dem
1247 @code{props}-Argument entnommen.
1250 #(define-markup-list-command (paragraph layout props args) (markup-list?)
1251 (let ((indent (chain-assoc-get 'par-indent props 2)))
1252 (interpret-markup-list layout props
1253 (make-justified-lines-markup-list (cons (make-hspace-markup indent)
1257 Neben den üblichen @code{layout} und @code{props}-Argumenten, nimmt der
1258 @code{paragraph}-Beschriftungslistenbefehl als Argument eine Beschriftungsliste,
1259 die @code{args} genannt wird. Das Prädikat für Beschriftungslisten ist
1260 @code{markup-list?}.
1262 Zuerst errechnet die Funktion die Breite des Einzugs, eine Eigenschaft
1263 mit der Bezeichnung @code{par-indent} anhand der Eigenschaftsliste
1264 @code{props}. Wenn die Eigenschaft nicht gefunden wird, ist der
1265 Standardwert @code{2}. Danach wird eine Liste von Zeilen im Blocksatz
1266 erstellt, wobei die @code{make-justified-lines-markup-list}-Funktion
1267 eingesetzt wird, die verwandt ist mit dem eingebauten
1268 @code{\justified-lines}-Beschriftungslistenbefehl. Horizontaler
1269 Platz wird zu Beginn eingefügt mit der @code{make-hspace-markup}-Funktion.
1270 Zuletzt wird die Beschriftungsliste ausgewertet durch die
1271 @code{interpret-markup-list}-Funktion.
1273 Dieser neue Beschriftungslistenbefehl kann wie folgt benutzt werden:
1278 Die Kunst des Notensatzes wird auch als \italic @{Notenstich@} bezeichnet. Dieser
1279 Begriff stammt aus dem traditionellen Notendruck. Noch bis vor etwa
1280 20 Jahren wurden Noten erstellt, indem man sie in eine Zink- oder
1281 Zinnplatte schnitt oder mit Stempeln schlug.
1283 \override-lines #'(par-indent . 4) \paragraph @{
1284 Diese Platte wurde dann mit Druckerschwärze versehen, so dass sie
1285 in den geschnittenen und gestempelten Vertiefungen blieb. Diese
1286 Vertiefungen schwärzten dann ein auf die Platte gelegtes Papier.
1287 Das Gravieren wurde vollständig von Hand erledigt.
1294 @node Contexts for programmers
1295 @section Contexts for programmers
1298 * Context evaluation::
1299 * Running a function on all layout objects::
1302 @node Context evaluation
1303 @subsection Context evaluation
1305 @cindex Aufrufen von Code während der Interpretation
1306 @cindex On-the-fly Code ausführen
1308 @funindex \applyContext
1310 Kontexte können während ihrer Interpretation mit Scheme-Code
1311 modifiziert werden. Die Syntax hierfür ist
1314 \applyContext @var{function}
1317 @var{function} sollte eine Scheme-Funktion sein, die ein
1318 einziges Argument braucht, welches der Kontext ist, auf den
1319 sie ausgeführt werden soll. Der folgende Code schreibt
1320 die aktuelle Taktzahlshould in die Standardausgabe
1321 während der Kompilation.
1326 (format #t "\nWe were called in barnumber ~a.\n"
1327 (ly:context-property x 'currentBarNumber)))
1332 @node Running a function on all layout objects
1333 @subsection Running a function on all layout objects
1336 @cindex Aufruf von Code für Layoutobjekte
1338 @funindex \applyOutput
1340 Der vielfältigste Weg, ein Objekt zu beeinflussen, ist
1341 @code{\applyOutput}. Die Syntax lautet:
1344 \applyOutput @var{Kontext} @var{proc}
1348 wobei @var{proc} eine Scheme-Funktion ist, die drei Argumente
1351 Während der Interpretation wird die Funktion @var{proc} für
1352 jedes Layoutobjekt aufgerufen, dass im Kontext @var{Kontext}
1353 vorgefunden wird, und zwar mit folgenden Argumenten:
1356 @item dem Layoutobjekt
1357 @item dem Kontext, in dem das Objekt erstellt wurde
1358 @item dem Kontext, in welchem @code{\applyOutput} bearbeitet wird.
1361 Zusätzlich findet sich der Grund für das Layoutobjekt, etwa
1362 der musikalische Ausdruck oder das Objekt, das für seine Erstellung
1363 verantwortlich war, in der Objekteigenschaft @code{cause}.
1364 Für einen Notenkopf beispielsweise ist das ein
1365 @rinternals{NoteHead}-Ereignis, und für einen Notenhals
1366 (ein @rinternals{Stem}-Objekt) ist es ein @rinternals{NoteHead}-Objekt.
1368 Hier ist eine Funktion, die mit @code{\applyOutput} benutzt
1369 werden kann; sie macht Notenköpfe auf der Mittellinie unsichtbar:
1371 @lilypond[quote,verbatim,ragged-right]
1372 #(define (blanker grob grob-origin context)
1373 (if (and (memq 'note-head-interface (ly:grob-interfaces grob))
1374 (eq? (ly:grob-property grob 'staff-position) 0))
1375 (set! (ly:grob-property grob 'transparent) #t)))
1378 e4 g8 \applyOutput #'Voice #blanker b d2
1383 @node Scheme procedures as properties
1384 @section Scheme procedures as properties
1386 Eigenschaften (wie Dicke, Richtung usw.) können mit
1387 @code{\override} auf feste Werte gesetzt werden, etwa:
1390 \override Stem #'thickness = #2.0
1393 Eigenschaften können auch auf eine Scheme-Prozedur gesetzt werden:
1395 @lilypond[fragment,verbatim,quote,relative=2]
1396 \override Stem #'thickness = #(lambda (grob)
1397 (if (= UP (ly:grob-property grob 'direction))
1404 In diesem Fall wird die Prozedur ausgeführt, sobal der Wert der
1405 Eigenschaft während das Formatierungsprozesses angefordert wird.
1407 Der größte Teil der Satzmaschinierie funtioniert mit derartigen
1408 Callbacks. Eigenschaften, die üblicherweise Callbacks
1409 benutzen, sind u. A.:
1413 Die Druckfunktion, die eine Ausgabe des Symbols ervorruft
1415 Die Funktion, die die horizontale Position setzt
1417 Die Funktion, die die Breite eines Objekts errechnet
1420 Die Funktionen brauchen immer ein einziges Argument, das der
1423 Wenn Funktionen mit mehreren Argumenten aufgerufen werden müssen,
1424 kann der aktuelle Grob mit einer Grob-Einschließung
1425 eingefügt werden. Hier eine Einstellung aus
1426 @code{AccidentalSuggestion}:
1430 ,(ly:make-simple-closure
1432 ,(ly:make-simple-closure
1433 (list ly:self-alignment-interface::centered-on-x-parent))
1434 ,(ly:make-simple-closure
1435 (list ly:self-alignment-interface::x-aligned-on-self)))))
1439 In diesem Beispiel werden sowohl @code{ly:self-alignment-interface::x-aligned-on-self}
1440 als auch @code{ly:self-alignment-interface::centered-on-x-parent}
1441 mit dem Grob als Argument aufgerufen. Die Resultate werden mit der
1442 @code{+}-Funktion addiert. Um sicherzugehen, dass die Addition
1443 richtig ausgeführt wird, wird das ganze Konstrukt in
1444 @code{ly:make-simple-closure} eingeschlossen.
1446 In der Tat ist die Benutzung einer einzelnen Funktion als
1447 Eigenschaftswert äquivalent zu
1450 (ly:make-simple-closure (ly:make-simple-closure (list @var{proc})))
1454 Das innere @code{ly:make-simple-closure} stellt den Grob als Argument
1455 für @var{proc} zur Verfügung, das äußere stellt sicher, dass das
1456 Resultat der Funktion ausgegeben wird und nicht das
1457 @code{simple-closure}-Objekt.
1460 @node Using Scheme code instead of \tweak
1461 @section Using Scheme code instead of @code{\tweak}
1463 Der hauptsächliche Nachteil von @code{\tweak} ist seine
1464 syntaktische Inflexibilität. Folgender Code beispielsweise
1465 ergibt einen Syntaxfehler:
1468 F = \tweak #'font-size #-3 -\flageolet
1476 Anders gesagt verhält sich @code{\tweak} nicht wie eine Artikulation
1477 und kann auch nicht deren Syntax verwenden: man kann es nicht
1478 mit @code{^} oder @code{_} anfügen.
1480 Durch die Verwendung von Scheme kann dieses Problem umgangen werden.
1481 Der Weg zum Resultat wird gezeigt in
1482 @ref{Adding articulation to notes (example)}, insbesondere
1483 wie @code{\displayMusic} benutzt wird, hilft hier weiter.
1486 F = #(let ((m (make-music 'ArticulationEvent
1487 'articulation-type "flageolet")))
1488 (set! (ly:music-property m 'tweaks)
1489 (acons 'font-size -3
1490 (ly:music-property m 'tweaks)))
1499 In diesem Beispiel werden die @code{tweaks}-Eigenschaften
1500 des Flageolet-Objekts @code{m} (mit @code{make-music} erstellt)
1501 werden mit @code{ly:music-property} ausgelesen, ein neues
1502 Schlüssel-Wert-Paar, um die Schriftgröße zu ändern, wird
1503 der Eigenschaftenliste mithilfe der @code{acons}-Schemefunktion
1504 vorangestellt, und das Resultat wird schließlich mit
1505 @code{set!} zurückgeschrieben. Das letzte Element des
1506 @code{let}-Blocks ist der Wiedergabewert, @code{m}.
1510 @node Difficult tweaks
1511 @section Difficult tweaks
1513 Hier finden sich einige Klassen an schwierigeren Anpassungen.
1518 Ein Typ der schwierigen Anpassungen ist die Erscheinung von
1519 Strecker-Objekten wie Binde- oder Legatobögen. Zunächst wird
1520 nur eins dieser Objekte erstellt, und sie können mit dem
1521 normalen Mechanismus verändert werden. In einigen Fällen
1522 reichen die Strecker jedoch über Zeilenumbrüche. Wenn das
1523 geschieht, werden diese Objekte geklont. Ein eigenes
1524 Objekt wird für jedes System erstellt, in dem es sich befindet.
1525 Sie sind Klone des originalen Objektes und erben alle
1526 Eigenschaften, auch @code{\override}-Befehle.
1528 Anders gesagt wirkt sich ein @code{\override} immer auf alle
1529 Stücke eines geteilten Streckers aus. Um nur einen Teil eines
1530 Streckers bei einem Zeilenumbruch zu verändern, ist es notwendig,
1531 in den Formatierungsprozess einzugreifen. Das Callback
1532 @code{after-line-breaking} enthält die Schemefunktion, die
1533 aufgerufen wird, nachdem Zeilenumbrüche errechnet worden sind
1534 und die Layout-Objekte über die unterschiedlichen Systeme verteilt
1537 Im folgenden Beispiel wird die Funktion
1538 @code{my-callback} definiert. Diese Funktion
1542 bestimmt, ob das Objekt durch Zeilenumbrüche geteilt ist,
1544 wenn ja, ruft sie alle geteilten Objekte auf,
1546 testet, ob es sich um das letzte der geteilten Objekte handelt,
1548 wenn ja, wird @code{extra-offset} gesetzt.
1551 Diese Funktion muss in @rinternals{Tie} (Bindebogen) installiert
1552 werden, und der letzte Teil eines gebrochenen Bindebogens wird
1553 nach oben verschoben.
1555 @lilypond[quote,verbatim,ragged-right]
1556 #(define (my-callback grob)
1558 ; have we been split?
1559 (orig (ly:grob-original grob))
1561 ; if yes, get the split pieces (our siblings)
1562 (siblings (if (ly:grob? orig)
1563 (ly:spanner-broken-into orig) '() )))
1565 (if (and (>= (length siblings) 2)
1566 (eq? (car (last-pair siblings)) grob))
1567 (ly:grob-set-property! grob 'extra-offset '(-2 . 5)))))
1570 \override Tie #'after-line-breaking =
1577 Wenn man diesen Trick anwendet, sollte das neue @code{after-line-breaking}
1578 auch das alte @code{after-line-breaking}-Callback aufrufen,
1579 wenn es vorhanden ist. Wenn diese Funktion etwa mit
1580 @code{Hairpin} (Crescendo-Klammer) eingesetzt wird, sollte auch
1581 @code{ly:hairpin::after-line-breaking} aufgerufen werden.
1585 Manche Objekte können aus technischen Gründen nicht mit @code{\override}
1586 verändert werden. Beispiele hiervon sind @code{NonMusicalPaperColumn}
1587 und @code{PaperColumn}. Sie können mit der
1588 @code{\overrideProperty}-Funktion geändert werden, die ähnlich wie
1589 @code{\once \override} funktioniert, aber eine andere Syntax einsetzt.
1593 #"Score.NonMusicalPaperColumn" % Grob-Bezeichnung
1594 #'line-break-system-details % Eigenschaftsbezeichnung
1595 #'((next-padding . 20)) % Wert
1598 Es sollte angemerkt werden, dass @code{\override}, wenn man es auf
1599 @code{NonMusicalPaperColumn} und @code{PaperColumn} anwendet, immernoch
1600 innerhalb der @code{\context}-Umgebung funktioniert.