1 @c -*- coding: utf-8; mode: texinfo; -*-
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 Schnittstellen für Programmierer
13 @chapter Schnittstellen für Programmierer
14 @translationof Interfaces for programmers
16 Fortgeschrittene Anpassungen können mithilfe der Programmiersprache
17 Scheme vorgenommen werden. Wenn Sie Scheme nicht kennen, gibt
18 es eine grundlegende Einleitung in LilyPonds
19 @rlearning{Scheme-Übung}.
22 * Musikalische Funktionen::
23 * Schnittstelle für Programmierer::
24 * Komplizierte Funktionen erstellen::
25 * Programmierungsschnittstelle für Textbeschriftungen::
26 * Kontexte für Programmierer::
27 * Scheme-Vorgänge als Eigenschaften::
28 * Scheme-Code anstelle von \tweak verwenden::
29 * Schwierige Korrekturen::
33 @node Musikalische Funktionen
34 @section Musikalische Funktionen
35 @translationof Music functions
37 Dieser Abschnitt behandelt die Erstellung von musikalischen Funktionen
38 innerhalb von LilyPond.
41 * Überblick über musikalische Funktionen::
42 * Einfache Ersetzungsfunktionen::
43 * Paarige Ersetzungsfunktionen::
44 * Mathematik in Funktionen::
46 * Funktionen ohne Argumente::
47 * Überblick über vorhandene musikalische Funktionen::
50 @node Überblick über musikalische Funktionen
51 @subsection Überblick über musikalische Funktionen
52 @translationof Overview of music functions
54 Es ist einfach, eine Funktion zu erstellen, die Variablen
55 im LilyPond-Code ersetzt. Die allgemeine Form derartiger
60 #(define-music-function (parser location @var{var1} @var{var2}...@var{vari}... )
61 (@var{var1-type?} @var{var2-type?}...@var{vari-type?}...)
70 @multitable @columnfractions .33 .66
71 @item @var{vari} @tab die @var{i}te Variable
72 @item @var{vari-type?} @tab die Art der @var{i}ten Variable
73 @item @var{...Noten...} @tab normaler LilyPond-Code, in dem Variablen
74 wie @code{#$var1} usw. benutzt werden.
77 Die folgenden Eingabetypen können als Variablen in einer musikalischen
78 Funktion benutzt werden. Diese Liste ist nicht vollständig -- siehe
79 auch andere Dokumentationen überScheme für weitere Variablenarten.
81 @multitable @columnfractions .33 .66
82 @headitem Eingabetyp @tab @var{vari-type?}-Notation
83 @item Ganzzahl @tab @code{integer?}
84 @item Float (Dezimalzahl) @tab @code{number?}
85 @item Zeichenkette @tab @code{string?}
86 @item Textbeschriftung @tab @code{markup?}
87 @item Musikalischer Ausdruck @tab @code{ly:music?}
88 @item Ein Variablenpaar @tab @code{pair?}
91 Die Argumente @code{parser} und @code{location} sind zwingend erforderlich
92 und werden in einigen fortgeschrittenen Situationen eingesetzt. Das
93 Argument @code{parser} wird benutzt, um auf den Wert einer weiteren
94 LilyPond-Variable zuzugreifen. Das Argument @code{location} wird
95 benutzt, um den @qq{Ursprung} des musikalischen Ausdrucks zu definieren, der von
96 der musikalischen Funktion erzeugt wird. Das hilft, wenn ein
97 Syntaxfehler auftaucht: in solchen Fällen kann LilyPond mitteilen,
98 an welcher Stelle in der Eingabedatei sich der Fehler befindet.
101 @node Einfache Ersetzungsfunktionen
102 @subsection Einfache Ersetzungsfunktionen
103 @translationof Simple substitution functions
105 Hier ist ein einfaches Beispiel:
107 @lilypond[quote,verbatim,ragged-right]
108 padText = #(define-music-function (parser location padding) (number?)
110 \once \override TextScript #'padding = #$padding
118 c4^"piu mosso" fis a g
122 Musikalische Ausdrücke können auch ersetzt werden:
124 @lilypond[quote,verbatim,ragged-right]
125 custosNote = #(define-music-function (parser location note)
128 \once \override Voice.NoteHead #'stencil =
129 #ly:text-interface::print
130 \once \override Voice.NoteHead #'text =
131 \markup \musicglyph #"custodes.mensural.u0"
132 \once \override Voice.Stem #'stencil = ##f
136 { c' d' e' f' \custosNote g' }
139 Mehrere Variablen können benutzt werden:
141 @lilypond[quote,verbatim,ragged-right]
142 tempoPadded = #(define-music-function (parser location padding tempotext)
145 \once \override Score.MetronomeMark #'padding = $padding
146 \tempo \markup { \bold $tempotext }
150 \tempo \markup { "Low tempo" }
152 \tempoPadded #4.0 #"High tempo"
158 @node Paarige Ersetzungsfunktionen
159 @subsection Paarige Ersetzungsfunktionen
160 @translationof Paired substitution functions
162 Einige @code{\override}-Befehle benötigen ein Zahlenpaar
163 (als @code{cons}-Zelle in Scheme bezeichnet). Um beide Zahlen
164 einer Funktion zuzuweisen, kann entweder die Variable @code{pair?}
165 benutzt werden oder die @code{cons} in die musikalische Funktion
171 #(define-music-function (parser location beg-end)
174 \once \override Beam #'positions = #$beg-end
178 \manualBeam #'(3 . 6) c8 d e f
186 @lilypond[quote,verbatim,ragged-right]
188 #(define-music-function (parser location beg end)
191 \once \override Beam #'positions = #(cons $beg $end)
195 \manualBeam #3 #6 c8 d e f
200 @node Mathematik in Funktionen
201 @subsection Mathematik in Funktionen
202 @translationof Mathematics in functions
204 Musikalische Funktionen können neben einfachen Ersetzungen
205 auch Scheme-Programmcode enthalten:
207 @lilypond[quote,verbatim,ragged-right]
208 AltOn = #(define-music-function (parser location mag) (number?)
209 #{ \override Stem #'length = #$(* 7.0 mag)
210 \override NoteHead #'font-size =
211 #$(inexact->exact (* (/ 6.0 (log 2.0)) (log mag))) #})
214 \revert Stem #'length
215 \revert NoteHead #'font-size
218 { c'2 \AltOn #0.5 c'4 c'
219 \AltOn #1.5 c' c' \AltOff c'2 }
223 Dieses Beispiel kann auch umformuliert werden, um musikalische Ausdrücke
226 @lilypond[quote,verbatim,ragged-right]
227 withAlt = #(define-music-function (parser location mag music) (number? ly:music?)
228 #{ \override Stem #'length = #$(* 7.0 mag)
229 \override NoteHead #'font-size =
230 #$(inexact->exact (* (/ 6.0 (log 2.0)) (log mag)))
232 \revert Stem #'length
233 \revert NoteHead #'font-size #})
235 { c'2 \withAlt #0.5 {c'4 c'}
236 \withAlt #1.5 {c' c'} c'2 }
240 @node Leere Funktionen
241 @subsection Leere Funktionen
242 @translationof Void functions
244 Eine musikalische Funktion muss einen musikalischen Ausdruck
245 ausgeben, aber in manchen Fällen müssen Funktionen erstellt werden,
246 die keine Notation enthalten (wie etwa eine Funktion, mit der
247 man @qq{Point and Click} ausschalten kann). Um das vornehmen zu
248 können, wird ein @code{leere}r musikalischer Ausdruck ausgegeben.
250 Das ist der Grund, warum die Form, die ausgegeben wird,
251 @code{(make-music ...)} heißt. Wird die Eigenschaft
252 @code{'void} (engl. für @qq{leer}) auf @code{#t} gesetzt, wird der
253 Parser angewiesen, den ausgegebenen musikalischen Ausdruck zu ignorieren.
254 Der maßgebliche Teil der @code{'void}-Funktion ist also die Verarbeitung,
255 die die Funktion vornimmt, nicht der musikalische Ausdruck, der ausgegeben
260 #(define-music-function (parser location) ()
261 (ly:set-option 'point-and-click #f)
262 (make-music 'SequentialMusic 'void #t))
264 \noPointAndClick % disable point and click
268 @node Funktionen ohne Argumente
269 @subsection Funktionen ohne Argumente
270 @translationof Functions without arguments
272 In den meisten Fällen sollten Funktionen ohne Argumente mit einer
273 Variable notiert werden:
276 dolce = \markup@{ \italic \bold dolce @}
279 In einigen wenigen Fällen kann es aber auch sinnvoll sein, eine
280 musikalische Funktion ohne Argumente zu erstellen:
284 #(define-music-function (parser location) ()
285 (if (eq? #t (ly:get-option 'display-bar-numbers))
286 #@{ \once \override Score.BarNumber #'break-visibility = ##f #@}
290 Damit auch wirklich Taktzahlen angezeigt werden, wo die
291 Funktion eingesetzt wurde, muss @command{lilypond} mit
295 lilypond -d display-bar-numbers Dateiname.ly
302 @node Überblick über vorhandene musikalische Funktionen
303 @subsection Überblick über vorhandene musikalische Funktionen
304 @translationof Overview of available music functions
306 @c fixme ; this should be move somewhere else?
307 Die folgenden Befehle sind musikalische Funktionen:
309 @include identifiers.tely
313 @node Schnittstelle für Programmierer
314 @section Schnittstelle für Programmierer
315 @translationof Programmer interfaces
317 Dieser Abschnitt zeigt, wie LilyPond und
318 Scheme gemischt werden können.
321 * Eingabevariablen und Scheme::
322 * Interne Repräsentation der Musik::
326 @node Eingabevariablen und Scheme
327 @subsection Eingabevariablen und Scheme
328 @translationof Input variables and Scheme
330 Das Eingabeformat unterstützt die Notation von Variablen: im
331 folgenden Beispiel wird ein musikalischer Ausdruck einer Variable
332 mit der Bezeichnung @code{traLaLa} zugewiesen:
335 traLaLa = @{ c'4 d'4 @}
338 Der Geltungsbereich von Variablen ist beschränkt: im folgenden
339 Beispiel enthält die @code{\layout}-Umgebung auch eine
340 @code{traLaLa}-vVariable, die unabhängig von der äußeren
341 @code{\traLaLa}-Variable ist:
344 traLaLa = @{ c'4 d'4 @}
345 \layout @{ traLaLa = 1.0 @}
348 Grundsätzlich ist jede Eingabedatei ein Geltungsbereich, und
349 alle @code{\header}-, @code{\midi}- und @code{\layout}-Umgebungen
350 sind Geltungsbereiche, die unterhalb des globalen Geltungsbereiches
353 Sowohl Variablen als auch Geltungsbereiche sind in Form des
354 GUILE-Modulsystems implementiert. Ein anonymes Scheme-Modul
355 wird an jeden Geltunsbereich angehängt. Eine Zuweisung der form
358 traLaLa = @{ c'4 d'4 @}
362 wird intern in die Scheme-Definition
365 (define traLaLa @var{Scheme-Wert von `@code{... }'})
371 Das bedeutet, dass Eingabe- und Scheme-Variablen frei vermischt
372 werden können. Im nächsten Beispiel wird ein Notenfragment in
373 der Variable @code{traLaLa} gespeichert und mithilfe von Schme
374 dupliziert. Das Ergebnis wird in eine @code{\score}-Umgebung
375 mit der zweiten Variable @code{twice} integriert:
378 traLaLa = { c'4 d'4 }
380 %% dummy action to deal with parser lookahead
381 #(display "this needs to be here, sorry!")
383 #(define newLa (map ly:music-deep-copy
384 (list traLaLa traLaLa)))
386 (make-sequential-music newLa))
391 In diesem Beispiel geschieht die Zuweisung, nachdem der Parser
392 festgestellt hat, dass nichts interessantes mehr nach
393 @code{traLaLa = @{ ... @}} vorkommt. Ohne die Pseudovariable
394 in dem Beispiel würde die @code{newLa}-Devinition ausgeführt
395 werden, bevor @code{traLaLa} definiert ist, was zu einem
396 Syntax-Fehler führen würde.
398 Das obige Beispiel zeigt, wie man musikalische Ausdrücke
399 von der Eingabe in den Scheme-Interpretierer @qq{exportieren}
400 kann. Es geht auch in die andere Richtung. Indem man einen
401 Scheme-Wert in die Funktion @code{ly:export} einpackt, wird
402 der Scheme-Wert interpretiert als ob er in LilyPond-Syntax
403 notiert worden wäre. Anstatt @code{\twice} zu definieren,
404 hätte man also auch schreiben können:
408 @{ #(ly:export (make-sequential-music (list newLa))) @}
411 Scheme-Code wird sofort ausgewertet, wenn der Parser darauf
412 stößt. Um Scheme-Code in einem Makro zu definieren (das dann
413 erst später aufgerufen werden soll), müssen leere Funktionen
414 benutzt werden (siehe @ref{Leere Funktionen}) oder das Folgende:
418 (ly:set-option 'point-and-click #f))
427 Scheme- und LilyPond-Variablen können im LilyPond-Modus mit der
428 @code{--safe}-Option nicht vermischt werden.
431 @node Interne Repräsentation der Musik
432 @subsection Interne Repräsentation der Musik
433 @translationof Internal music representation
435 Wenn ein musikalischer Ausdruck ausgewertet wird, wird er in eine
436 Anzahl von musikalischen Scheme-Objekten konvertiert. Die Eigenschaft, die ein
437 musikalisches Objekt definiert, ist, dass es Zeit einnimmt. Zeit ist
438 eine rationale Zahl, die die Länge eines Stückes in ganzen Noten
441 Ein musikalisches Objekt hat drei Typusarten:
444 musikalische Bezeichnung: Jeder musikalische Ausdruck hat eine Bezeichnung.
445 Eine Note beispielsweise führt zu einem @rinternals{NoteEvent} und
446 @code{\simultaneous} führt zu @rinternals{SimultaneousMusic}. Eine Liste
447 aller möglichen Ausdrücke findet sich in der Referenz der Interna, unter
448 @rinternals{Music expressions}.
451 @q{Typ} oder Schnittstelle: Jede musikalische Bezeichnung hat mehrere
452 @qq{Typen} oder Schnittstellten, beispielsweise ist eine Note ein
453 @code{event}, ober sie ist auch ein @code{note-event}, ein
454 @code{rhythmic-event} und ein @code{melodic-event}. Alle diese
455 Notationsklassen finden sich in der Referenz der Interna unter
456 @rinternals{Music classes}.
459 C++-Objekt: Jedes musikalische Objekt wird von einem Objekt der
460 C++-Klasse @code{Music} repräsentiert.
463 Die eigentlich Information eines musikalischen Ausdrucks ist in
464 Eigenschaften gespeichert. Ein @rinternals{NoteEvent} hat zum
465 Beispiel @code{pitch}- und @code{duration}-Eigenschaften, die
466 die Tonhöhe und die Dauer dieser Note speichern. Eine Liste aller
467 verfügbaren Eigenschaften findet sich in der Referenz der Interna unter
468 @rinternals{Music properties}.
470 Ein zusammengesetzter musikalischer Ausdruck ist ein musikalisches
471 Objekt, das andere Objekte in seinen Eigenschaften enthält. Eine Liste
472 der Objekte kann in der @code{elements}-Eigenschaft eines
473 musikalischen Objektes gespeichert werden, oder ein einziges
474 @qq{Kind}-Objekt in der @code{element}-Eigenschaft. Sa hat etwa
475 @rinternals{SequentialMusic} seine @qq{Kinder} in @code{elements},
476 und @rinternals{GraceMusic} hat sein einziges Argument in
477 @code{element}. Der Hauptteil einer Wiederholung wird in der
478 @code{element}-Eigenschaft von @rinternals{RepeatedMusic} gespeichert,
479 und die Alternativen in @code{elements}.
483 @node Komplizierte Funktionen erstellen
484 @section Komplizierte Funktionen erstellen
485 @translationof Building complicated functions
487 Dieser Abschnitt zeigt, wie man Information zusammensucht,
488 um komplizierte musikalische Funktionen zu erstellen.
491 * Musikalische Funktionen darstellen::
492 * Eigenschaften von Musikobjekten::
493 * Verdoppelung einer Note mit Bindebögen (Beispiel)::
494 * Artikulationszeichen zu Noten hinzufügen (Beispiel)::
498 @node Musikalische Funktionen darstellen
499 @subsection Musikalische Funktionen darstellen
500 @translationof Displaying music expressions
502 @cindex interne Speicherung
503 @cindex Musikausdrücke anzeigen
504 @cindex Anzeigen von Musikausdrücken
506 @funindex displayMusic
507 @funindex \displayMusic
509 Wenn man eine musikalische Funktion erstellt, ist es oft
510 hilfreich sich anzuschauen, wie musikalische Funktionen
511 intern gespeichert werden. Das kann mit der Funktion
512 @code{\displayMusic} erreicht werden:
516 \displayMusic @{ c'4\f @}
533 (ly:make-duration 2 0 1 1)
535 (ly:make-pitch 0 0 0))
537 'AbsoluteDynamicEvent
542 Normalerweise gibt LilyPond diese Ausgabe auf der Konsole mit
543 allen anderen Nachrichten aus. Um die wichtigen Nachrichten
544 in einer Datei zu speichern, kann die Ausgabe in eine Datei
548 lilypond file.ly >display.txt
551 Mit etwas Umformatierung ist die gleiche Information sehr viel
555 (make-music 'SequentialMusic
556 'elements (list (make-music 'EventChord
557 'elements (list (make-music 'NoteEvent
558 'duration (ly:make-duration 2 0 1 1)
559 'pitch (ly:make-pitch 0 0 0))
560 (make-music 'AbsoluteDynamicEvent
564 Eine musikalische @code{@{ ... @}}-Sequenz hat die Bezeichnung
565 @code{SequentialMusic} und ihre inneren Ausdrücke werden als
566 Liste in seiner @code{'elements}-Eigenschaft gespeichert. Eine
567 Note ist als als ein @code{EventChord}-Ausdruck dargestellt,
568 der ein @code{NoteEvent}-Objekt (welches Dauer und
569 Tonhöhe speichert) und zusätzliche Information enthält (in
570 diesem Fall ein @code{AbsoluteDynamicEvent} mit einer
571 @code{"f"}-Text-Eigenschaft.
574 @node Eigenschaften von Musikobjekten
575 @subsection Eigenschaften von Musikobjekten
576 @translationof Music properties
578 Das @code{NoteEvent}-Objekt ist das erste Objekt der
579 @code{'elements}-Eigenschaft von @code{someNote}.
583 \displayMusic \someNote
591 (ly:make-duration 2 0 1 1)
593 (ly:make-pitch 0 0 0))))
596 Die @code{display-scheme-music}-Funktion ist die Funktion, die von
597 @code{\displayMusic} eingesetzt wird, um die Scheme-Repräsentation
598 eines musikalischen Ausdrucks anzuzeigen.
601 #(display-scheme-music (first (ly:music-property someNote 'elements)))
606 (ly:make-duration 2 0 1 1)
608 (ly:make-pitch 0 0 0))
611 Danach wird die Tonhöhe der Note von der @code{'pitch}-Eigenschaft
612 des @code{NoteEvent}-Objektes gelesen:
615 #(display-scheme-music
616 (ly:music-property (first (ly:music-property someNote 'elements))
619 (ly:make-pitch 0 0 0)
622 Die Tonhöhe einer Note kann geändert werden, indem man diese
623 @code{'pitch}-Eigenschaft umdefiniert:
625 @funindex \displayLilyMusic
626 @funindex displayLilyMusic
629 #(set! (ly:music-property (first (ly:music-property someNote 'elements))
631 (ly:make-pitch 0 1 0)) ;; Die Tonhöhen auf d' verändern.
632 \displayLilyMusic \someNote
638 @node Verdoppelung einer Note mit Bindebögen (Beispiel)
639 @subsection Verdoppelung einer Note mit Bindebögen (Beispiel)
640 @translationof Doubling a note with slurs (example)
642 In diesem Abschnitt soll gezeigt, werden, wie man eine
643 Funktion erstellt, die eine Eingabe wie @code{a}
644 nach @code{a( a)} umdefiniert. Dazu wird zuerst die
645 interne Repräsentation der Musik betrachtet, die
646 das Endergebnis darstellt:
649 \displayMusic@{ a'( a') @}
660 (ly:make-duration 2 0 1 1)
662 (ly:make-pitch 0 5 0))
673 (ly:make-duration 2 0 1 1)
675 (ly:make-pitch 0 5 0))
682 Eine schlechte Nachricht ist, dass die
683 @code{SlurEvent}-Ausdrücke @qq{innerhalb}
684 der Noten (bzw. innerhalb der
685 @code{EventChord}-Ausdrücke) hinzugefügt werden müssen.
687 Jetzt folgt eine Betrachtung der Eingabe:
699 (ly:make-duration 2 0 1 1)
701 (ly:make-pitch 0 5 0))))))
704 In der gewünschten Funktion muss also dieser Ausdruck
705 kopiert werden (sodass zwei Noten vorhanden sind, die
706 eine Sequenz bilden), dann müssen @code{SlurEvent}
707 zu der @code{'elements}-Eigenschaft jeder Noten hinzugefügt
708 werden, und schließlich muss eine @code{SequentialMusic}
709 mit den beiden @code{EventChords} erstellt werden.
712 doubleSlur = #(define-music-function (parser location note) (ly:music?)
713 "Return: @{ note ( note ) @}.
714 `note' is supposed to be an EventChord."
715 (let ((note2 (ly:music-deep-copy note)))
716 (set! (ly:music-property note 'elements)
717 (cons (make-music 'SlurEvent 'span-direction -1)
718 (ly:music-property note 'elements)))
719 (set! (ly:music-property note2 'elements)
720 (cons (make-music 'SlurEvent 'span-direction 1)
721 (ly:music-property note2 'elements)))
722 (make-music 'SequentialMusic 'elements (list note note2))))
726 @node Artikulationszeichen zu Noten hinzufügen (Beispiel)
727 @subsection Artikulationszeichen zu Noten hinzufügen (Beispiel)
728 @translationof Adding articulation to notes (example)
730 Am einfachsten können Artikulationszeichen zu Noten
731 hinzugefügt werden, indem man zwei musikalische Funktionen
732 in einen Kontext einfügt, wie erklärt in
733 @ref{Kontexte erstellen}. Hier soll jetzt eine musikalische
734 Funktion entwickelt werden, die das vornimmt.
736 Eine @code{$variable} innerhalb von @code{#@{...#@}} ist das
737 gleiche wie die normale Befehlsform @code{\variable} in
738 üblicher LilyPond-Notation. Es ist bekannt dass
745 in LilyPond nicht funktioniert. Das Problem könnte vermieden
746 werden, indem das Artikulationszeichen an eine Pseudonote
750 @{ << \music s1*0-.-> @}
754 aber in diesem Beispiel soll gezeigt werden, wie man das in
755 Scheme vornimmt. Zunächst wird die Eingabe und die gewünschte
768 (ly:make-duration 2 0 1 1)
770 (ly:make-pitch -1 0 0))))
781 (ly:make-duration 2 0 1 1)
783 (ly:make-pitch -1 0 0))
790 Dabei ist zu sehen, dass eine Note (@code{c4}) als @code{EventChord}
791 repräsentiert ist, mit einem @code{NoteEvent}-Ausdruck in ihrer
792 Elementenliste. Um eine Marcato-Artikulation hinzuzufügen, muss
793 ein @code{ArticulationEvent}-Ausdrcuk zu der Elementeigenschaft
794 des @code{EventChord}-Ausdrucks hinzugefügt werden.
796 Um diese Funktion zu bauen, wird folgerndermaßen begonnen:
799 (define (add-marcato event-chord)
800 "Add a marcato ArticulationEvent to the elements of `event-chord',
801 which is supposed to be an EventChord expression."
802 (let ((result-event-chord (ly:music-deep-copy event-chord)))
803 (set! (ly:music-property result-event-chord 'elements)
804 (cons (make-music 'ArticulationEvent
805 'articulation-type "marcato")
806 (ly:music-property result-event-chord 'elements)))
810 Die erste Zeile definiert eine Funktion in Scheme: Die Bezeichnung
811 der Funktion ist @code{add-marcato} und sie hat eine Variable
812 mit der Bezeichnung @code{event-chord}. In Scheme geht der Typ
813 einer Variable oft direkt aus der Bezeichnung hervor (das ist auch
814 eine gute Methode für andere Programmiersprachen).
821 ist eine (englische) Beschreibung, was diese Funktion tut. Sie ist
822 nicht unbedingt notwendig, aber genauso wie klare Variablen-Bezeichnungen
823 ist auch das eine gute Methode.
826 (let ((result-event-chord (ly:music-deep-copy event-chord)))
829 @code{let} wird benutzt, um die lokalen Variablen zu definieren. Hier
830 wird eine lokale Variable benutzt: @code{result-event-chord}. Sie erhält
831 den Wert @code{(ly:music-deep-copy event-chord)}. @code{ly:music-deep-copy}
832 ist eine LilyPond-spezifische Funktion, die wie alle Funktionen mit dem
833 Präfix @code{ly:} versehen ist. Sie wird benutzt, um eine Kopie eines
834 musikalischen Ausdrucks anzufertigen. Hier wird @code{event-chord}
835 (der Parameter der Funktion) kopiert. Die Funktion soll ja nur ein
836 Artikulationszeichen an einen @code{EventChord} gehängt werden, deshalb ist es besser,
837 den @code{EventChord}, der als Argument gegeben wurde, nicht zu
838 verändern, weil er woanders benutzt werden könnte.
840 Jetzt gibt es @code{result-event-chord}, wobei es sich um einen
841 @code{NoteEventChord}-Ausdruck handelt, welcher gleichzeigt eine Kopie
842 von @code{event-chord} ist. Das Makro wird seiner Eigenschaftsliste
846 (set! place new-value)
849 Was in diesem Fall @qq{gesetzt} werden soll (@qq{place}) ist die
850 @q{elements}-Eigenschaft des @code{result-event-chord}-Ausdrucks.
853 (ly:music-property result-event-chord 'elements)
856 @code{ly:music-property} ist die Funktion, mit der musikalische
857 Eigenschaften erreicht werden können (die @code{'elements},
858 @code{'duration}, @code{'pitch} usw., die in der Ausgabe von
859 @code{\displayMusic} weiter oben angezeigt werden). Der neue
860 Wert ist, was ehemals die Elemtneigenschaft war, mit einem
861 zusätzlichen Element: dem @code{ArticulationEvent}-Ausdruck,
862 der aus der Ausgabe von
863 @code{\displayMusic} kopiert werden kann:
866 (cons (make-music 'ArticulationEvent
867 'articulation-type "marcato")
868 (ly:music-property result-event-chord 'elements))
871 @code{cons} wird benutzt, um ein Element zu einer Liste hinzuzufügen,
872 ohne dass die originale Liste verändert wird. Das ist es, was die
873 Funktion tun soll: die gleiche Liste, aber mit dem neuen
874 @code{ArticulationEvent}-Ausdruck. Die Reihenfolge innerhalb
875 der Elementeeigenschaft ist hier nicht relevant.
877 Wenn schließlich die Marcato-Artikulation zu der entsprechenden
878 @code{elements}-Eigenschaft hinzuzugefügt ist, kann
879 @code{result-event-chord} ausgegeben werden, darum die letzte Zeile
882 Jetzt wird die @code{add-marcato}-Funktion in eine musikalische
883 Funktion umgewandelt:
886 addMarcato = #(define-music-function (parser location event-chord)
888 "Add a marcato ArticulationEvent to the elements of `event-chord',
889 which is supposed to be an EventChord expression."
890 (let ((result-event-chord (ly:music-deep-copy event-chord)))
891 (set! (ly:music-property result-event-chord 'elements)
892 (cons (make-music 'ArticulationEvent
893 'articulation-type "marcato")
894 (ly:music-property result-event-chord 'elements)))
898 Eine Überprüfung, dass die Funktion richtig arbeitet, geschieht
902 \displayMusic \addMarcato c4
906 @node Programmierungsschnittstelle für Textbeschriftungen
907 @section Programmierungsschnittstelle für Textbeschriftungen
908 @translationof Markup programmer interface
910 Textbeschriftungselemente sind als besondere Scheme-Funktionen
911 definiert, die ein Stencil-Objekt erstellen, dem eine Anzahl
912 an Argumenten übergeben wird.
915 * Beschriftungskonstruktionen in Scheme::
916 * Wie Beschriftungen intern funktionieren::
917 * Neue Definitionen von Beschriftungsbefehlen::
918 * Neue Definitionen von Beschriftungsbefehlen für Listen::
922 @node Beschriftungskonstruktionen in Scheme
923 @subsection Beschriftungskonstruktionen in Scheme
924 @translationof Markup construction in Scheme
926 @cindex Textbeschriftungsbefehle, definieren
927 @cindex Textbeschriftung, eigene Befehle
928 @cindex eigene Befehle, Textbeschriftung
929 @cindex markup, eigene Befehle
930 @cindex Befehle definieren, Textbeschriftung
932 Das @code{markup}-(Textbeschriftungs)Makro erstellt Textbeschriftungs-Ausdrücke
933 in Scheme, wobei eine LilyPond-artige Syntax benutzt wird. Beispielsweise
937 (markup #:column (#:line (#:bold #:italic "hello" #:raise 0.4 "world")
938 #:larger #:line ("foo" "bar" "baz")))
945 \markup \column @{ \line @{ \bold \italic "hello" \raise #0.4 "world" @}
946 \larger \line @{ foo bar baz @} @}
950 Dieses Beispiel zeigt die hauptsächlichen Übersetzungsregeln
951 zwischen normaler Textbeschriftungssyntax von LilyPond und der
952 Textbeschriftungssyntax in Scheme.
955 @multitable @columnfractions .3 .3
956 @item @b{LilyPond} @tab @b{Scheme}
957 @item @code{\markup Text1} @tab @code{(markup Text1)}
958 @item @code{\markup @{ Text1 Text2 ... @}} @tab
959 @code{(markup Text1 Text2 ... )}
960 @item @code{\Befehl} @tab @code{#:Befehl}
961 @item @code{\Variable} @tab @code{Variable}
962 @item @code{\center-column @{ ... @}} @tab @code{#:center-column ( ... )}
963 @item @code{Zeichenkette} @tab @code{"Zeichenkette"}
964 @item @code{#scheme-arg} @tab @code{scheme-arg}
968 Die gesamte Scheme-Sprache ist innerhalb des @code{markup}-Makros
969 zugänglich. Man kann also beispielsweise Funktionen innerhalb
970 eines @code{markup} aufrufen, um Zeichenketten zu manipulieren.
971 Das ist nützlich, wenn neue Beschriftungsbefehle definiert werden
973 @ref{Neue Definitionen von Beschriftungsbefehlen}).
978 Das Beschriftungslistenargument von Befehlen wie @code{#:line},
979 @code{#:center} und @code{#:column} kann keine Variable oder
980 das Resultat eines Funktionsaufrufen sein.
983 (markup #:line (Funktion-die-Textbeschriftung-ausgibt))
987 ist ungültig. Man sollte anstatt dessen die Funktionen
988 @code{make-line-markup}, @code{make-center-markup} oder
989 @code{make-column-markup} benutzen:
992 (markup (make-line-markup (Funktion-die-Textbeschriftung-ausgibt)))
996 @node Wie Beschriftungen intern funktionieren
997 @subsection Wie Beschriftungen intern funktionieren
998 @translationof How markups work internally
1000 In einer Textbeschriftung wie
1003 \raise #0.5 "Textbeispiel"
1007 ist @code{\raise} unter der Haube durch die @code{raise-markup}-Funktion
1008 repräsentiert. Der Beschriftungsausdruck wird gespeichert als
1011 (list raise-markup 0.5 (list simple-markup "Textbeispiel"))
1014 Wenn die Beschriftung in druckbare Objekte (Stencils) umgewandelt ist,
1015 wir die @code{raise-markup}-Funktion folgendermaßen aufgerufen:
1019 @var{\layout object}
1020 @var{Liste der Eigenschafts-alists}
1022 @var{die "Textbeispiel"-Beschriftung})
1025 Die @code{raise-markup}-Funktion erstellt zunächt den Stencil für die
1026 @code{Textbeispiel}-Beschriftung und verschiebt dann diesen Stencil
1027 um 0.5 Notenlinienzwischenräume nach oben. Das ist ein einfaches
1028 Beispiel. Weitere, kompliziertere Beispiele finden sich nachfolgend
1029 in diesem Abschnitt und in der Datei
1030 @file{scm/@/define@/-markup@/-commands@/.scm}.
1033 @node Neue Definitionen von Beschriftungsbefehlen
1034 @subsection Neue Definitionen von Beschriftungsbefehlen
1035 @translationof New markup command definition
1037 Neue Textbeschriftungsbefehle können mit dem
1038 @code{define-markup-command}-Scheme-Makro definiert werden.
1041 (define-markup-command (@var{befehl-bezeichnung} @var{layout} @var{props} @var{arg1} @var{arg2} ...)
1042 (@var{arg1-type?} @var{arg2-type?} ...)
1050 @var{i}te Befehlsargument
1052 eine Eigenschaft für das @var{i}te Argument
1054 die @q{layout}-Definition
1056 eine Liste an alists, in der alle aktiven Eigenschaften enthalten sind
1059 Als einfaches Beispiel soll gezeigt werden, wie man einen
1060 @code{\smallcaps}-Befehl hinzufügen kann, der die Kapitälchen
1061 für die Schriftzeichen auswählt. Normalerweise würde man Kapitälchen
1062 folgendermaßen auswählen:
1065 \markup @{ \override #'(font-shape . caps) Text-in-Kapitälchen @}
1069 Damit wird die Kapitälchenschriftart ausgewählt, indem die
1070 @code{font-shape}-Eigesnchaft auf @code{#'caps} gesetzt wird,
1071 während @code{Text-in-caps} interpretiert wird.
1073 Damit diese Funkion als @code{\smallcaps}-Befehl zur Verfügung
1074 gestellt werden kann, muss eine Funktion mit @code{define-markup-command}
1075 definiert werden. Der Befehl braucht ein Argument vom Typ @code{markup}.
1076 Darum sollte der Beginn der Funktion lauten:
1079 (define-markup-command (smallcaps layout props argument) (markup?)
1084 Was jetzt folgt, ist der eigentliche Inhalt des Befehls: das
1085 @code{argument} soll als Beschriftung (markup) interpretiert werden,
1089 (interpret-markup layout @dots{} argument)
1093 Diese Interpretation sollte @code{'(font-shape . caps)} zu den
1094 aktiven Eigenschaften hinzufügen, weshalb wir das Folgende anstelle
1095 der @dots{} in dem Beispiel einfügen:
1098 (cons (list '(font-shape . caps) ) props)
1102 Die Variable @code{props} ist eine Liste an alists, und mit @code{cons}
1103 wird ihr eine zusätzliche Einstellung hinzugefügt.
1105 Man könnte sich auch vorstellen, dass ein Rezitativ einer Oper
1106 gesetzt werden soll, und ein Befehl wäre sehr bequem, mit dem
1107 man die Namen der Charaktere auf eine eigene Art darstellen könnte.
1108 Namen sollen in Kapitälchen gesetzt werden und etwas nach links und
1109 oben verschoben werden. Man kann also einen @code{\character}-Befehl
1110 definieren, der die nötige Verschiebung berücksichtigt und
1111 den neuen @code{\smallcaps}-Befehl einsetzt:
1114 #(define-markup-command (character layout props name) (string?)
1115 "Print the character name in small caps, translated to the left and
1116 top. Syntax: \\character #\"name\""
1117 (interpret-markup layout props
1118 (markup #:hspace 0 #:translate (cons -3 1) #:smallcaps name)))
1121 Hier ist eine Komplikation, die erklärt werden muss: Text über oder
1122 unter dem Notensystem wird vertikal verschoben um in einem bestimmten
1123 Abstand von dem System und den Noten zu sein (das wird als @qq{padding}
1124 bezeichnet). Um sicherzugehen, dass dieser Mechanismus nicht die
1125 vertikale Verschiebung von @code{#:translate} annulliert, wird
1126 die leere Zeichenkette (@code{#:hspace 0}) vor den zu verschiebenden
1127 Text gesetzt. Das @code{#:hspace 0} wird jetzt also über die Noten
1128 gesetzt und @code{name} dann relativ zu der leeren Zeichenkette
1129 verschoben. Im Endeffekt wird der Text nach links oben verschoben.
1131 Das Resultat sieht folgendermaßen aus:
1135 c''^\markup \character #"Cleopatra"
1136 e'^\markup \character #"Giulio Cesare"
1140 @lilypond[quote,ragged-right]
1141 #(define-markup-command (smallcaps layout props str) (string?)
1142 "Print the string argument in small caps. Syntax: \\smallcaps #\"string\""
1143 (interpret-markup layout props
1146 (if (= (string-length s) 0)
1148 (markup #:large (string-upcase (substring s 0 1))
1149 #:translate (cons -0.6 0)
1150 #:tiny (string-upcase (substring s 1)))))
1151 (string-split str #\Space)))))
1153 #(define-markup-command (character layout props name) (string?)
1154 "Print the character name in small caps, translated to the left and
1155 top. Syntax: \\character #\"name\""
1156 (interpret-markup layout props
1157 (markup #:hspace 0 #:translate (cons -3 1) #:smallcaps name)))
1160 c''^\markup \character #"Cleopatra" c'' c'' c''
1161 e'^\markup \character #"Giulio Cesare" e' e' e'
1165 In diesen Befehlen wurden Kapitälchen eingesetzt, aber es kann
1166 vorkommen, dass die Schriftart keine Kapitälchen zur Verfügung
1167 stellt. In diesem Fall können die Kapitälchen nachempfunden
1168 werden, indem man Großbuchstaben setzt, deren Anfangsbuchstabe
1169 etwas größer gesetzt wird:
1172 #(define-markup-command (smallcaps layout props str) (string?)
1173 "Print the string argument in small caps."
1174 (interpret-markup layout props
1177 (if (= (string-length s) 0)
1179 (markup #:large (string-upcase (substring s 0 1))
1180 #:translate (cons -0.6 0)
1181 #:tiny (string-upcase (substring s 1)))))
1182 (string-split str #\Space)))))
1185 Der @code{smallcaps}-Befehl spaltet die Argumente zuerst in
1186 Einzelstücke auf, die von Leerzeichen getrennt sind
1187 (@code{(string-split str #\Space)}); für jedes Einzelstück
1188 wird dann eine Beschriftung aufgebaut, deren erster Buchstabe
1189 vergrößert wird und als Versalbuchstabe gesetzt wird
1190 (@code{#:large (string-upcase (substring s 0 1))}), und eine
1191 zweite Versalbuchstaben gesetzt werden
1192 (@code{#:tiny (string-upcase (substring s 1))}). Wenn
1193 LilyPond ein Leerzeichen zwischen Beschriftungen einer Zeile
1194 entdeckt, wird die zweite Beschriftung nach links verschoben
1195 (@code{#:translate (cons -0.6 0) ...}). Dann werden die
1196 Beschriftungen für jedes Einzelstück in eine Zeile gesetzt
1197 @code{(make-line-markup ...)}. Schließlich wird die resultierende
1198 Beschriftung an die @code{interpret-markup}-Funktion zusammen
1199 mit den Argumenten @code{layout} und @code{props} weitergereicht.
1201 Achtung: ist gibt keinen internen Befehl @code{\smallCaps}, der
1202 benutzt werden kann, um Text in Kapitälchen zu setzen. Siehe auch
1203 @ref{Text markup commands}.
1207 Im Moment sind die möglichen Kombinationen von Argumenten (nach den
1208 Standardargumenten @var{layout} und @var{props}), die mit
1209 @code{define-markup-command} definiert werden, wie folgt
1213 @item (kein Argument)
1216 @itemx @var{markup markup}
1218 @itemx @var{scm markup}
1219 @itemx @var{scm scm}
1220 @itemx @var{scm scm markup}
1221 @itemx @var{scm scm markup markup}
1222 @itemx @var{scm markup markup}
1223 @itemx @var{scm scm scm}
1227 Hier stellt @var{scm} native Scheme-Datentypen dar wie
1228 @q{number} oder @q{string}.
1230 Es ist beispielsweise nicht möglich, einen Beschriftungsbefehl
1231 @code{foo} mit vier Argumenten in folgender Weise zu nutzen:
1234 #(define-markup-command (foo layout props
1235 num1 str1 num2 str2)
1236 (number? string? number? string?)
1241 Wenn es folgendermaßen eingesetzt wird:
1244 \markup \foo #1 #"bar" #2 #"baz"
1247 @cindex Scheme signature
1248 @cindex Signatur, Scheme
1250 beschwert sich @command{lilypond}, dass @code{foo} wegen einer ungekannten
1251 Scheme Signatur nicht analysiert werden kann.
1254 @node Neue Definitionen von Beschriftungsbefehlen für Listen
1255 @subsection Neue Definitionen von Beschriftungsbefehlen für Listen
1256 @translationof New markup list command definition
1258 Beschriftungslistenbefehle können mit dem Scheme-Makro
1259 @code{define-markup-list-command} definiert werden, welches
1260 sich ähnlich verhält wie das
1261 @code{define-markup-command}-Makro, das schon beschrieben
1262 wurde in @ref{Neue Definitionen von Beschriftungsbefehlen}. Ein Unterschied
1263 ist, dass bei diesem Listen-Makro eine ganze Liste an
1264 Stecils ausgegeben wird.
1266 Im folgenden Beispiel wird ein @code{\paragraph}-Beschriftungslistenbefehl
1267 definiert, welcher eine Liste von Zeilen im Blocksatz ausgibt, von
1268 denen die erste Zeile eingerückt ist. Der Einzug wird aus dem
1269 @code{props}-Argument entnommen.
1272 #(define-markup-list-command (paragraph layout props args) (markup-list?)
1273 (let ((indent (chain-assoc-get 'par-indent props 2)))
1274 (interpret-markup-list layout props
1275 (make-justified-lines-markup-list (cons (make-hspace-markup indent)
1279 Neben den üblichen @code{layout} und @code{props}-Argumenten, nimmt der
1280 @code{paragraph}-Beschriftungslistenbefehl als Argument eine Beschriftungsliste,
1281 die @code{args} genannt wird. Das Prädikat für Beschriftungslisten ist
1282 @code{markup-list?}.
1284 Zuerst errechnet die Funktion die Breite des Einzugs, eine Eigenschaft
1285 mit der Bezeichnung @code{par-indent} anhand der Eigenschaftsliste
1286 @code{props}. Wenn die Eigenschaft nicht gefunden wird, ist der
1287 Standardwert @code{2}. Danach wird eine Liste von Zeilen im Blocksatz
1288 erstellt, wobei die @code{make-justified-lines-markup-list}-Funktion
1289 eingesetzt wird, die verwandt ist mit dem eingebauten
1290 @code{\justified-lines}-Beschriftungslistenbefehl. Horizontaler
1291 Platz wird zu Beginn eingefügt mit der @code{make-hspace-markup}-Funktion.
1292 Zuletzt wird die Beschriftungsliste ausgewertet durch die
1293 @code{interpret-markup-list}-Funktion.
1295 Dieser neue Beschriftungslistenbefehl kann wie folgt benutzt werden:
1300 Die Kunst des Notensatzes wird auch als \italic @{Notenstich@} bezeichnet. Dieser
1301 Begriff stammt aus dem traditionellen Notendruck. Noch bis vor etwa
1302 20 Jahren wurden Noten erstellt, indem man sie in eine Zink- oder
1303 Zinnplatte schnitt oder mit Stempeln schlug.
1305 \override-lines #'(par-indent . 4) \paragraph @{
1306 Diese Platte wurde dann mit Druckerschwärze versehen, so dass sie
1307 in den geschnittenen und gestempelten Vertiefungen blieb. Diese
1308 Vertiefungen schwärzten dann ein auf die Platte gelegtes Papier.
1309 Das Gravieren wurde vollständig von Hand erledigt.
1316 @node Kontexte für Programmierer
1317 @section Kontexte für Programmierer
1318 @translationof Contexts for programmers
1321 * Kontextauswertung::
1322 * Eine Funktion auf alle Layout-Objekte anwenden::
1325 @node Kontextauswertung
1326 @subsection Kontextauswertung
1327 @translationof Context evaluation
1329 @cindex Aufrufen von Code während der Interpretation
1330 @cindex On-the-fly Code ausführen
1332 @funindex \applyContext
1334 Kontexte können während ihrer Interpretation mit Scheme-Code
1335 modifiziert werden. Die Syntax hierfür ist
1338 \applyContext @var{function}
1341 @var{function} sollte eine Scheme-Funktion sein, die ein
1342 einziges Argument braucht, welches der Kontext ist, auf den
1343 sie ausgeführt werden soll. Der folgende Code schreibt
1344 die aktuelle Taktzahlshould in die Standardausgabe
1345 während der Kompilation.
1350 (format #t "\nWe were called in barnumber ~a.\n"
1351 (ly:context-property x 'currentBarNumber)))
1356 @node Eine Funktion auf alle Layout-Objekte anwenden
1357 @subsection Eine Funktion auf alle Layout-Objekte anwenden
1358 @translationof Running a function on all layout objects
1361 @cindex Aufruf von Code für Layoutobjekte
1363 @funindex \applyOutput
1365 Der vielfältigste Weg, ein Objekt zu beeinflussen, ist
1366 @code{\applyOutput}. Die Syntax lautet:
1369 \applyOutput @var{Kontext} @var{proc}
1373 wobei @var{proc} eine Scheme-Funktion ist, die drei Argumente
1376 Während der Interpretation wird die Funktion @var{proc} für
1377 jedes Layoutobjekt aufgerufen, dass im Kontext @var{Kontext}
1378 vorgefunden wird, und zwar mit folgenden Argumenten:
1381 @item dem Layoutobjekt
1382 @item dem Kontext, in dem das Objekt erstellt wurde
1383 @item dem Kontext, in welchem @code{\applyOutput} bearbeitet wird.
1386 Zusätzlich findet sich der Grund für das Layoutobjekt, etwa
1387 der musikalische Ausdruck oder das Objekt, das für seine Erstellung
1388 verantwortlich war, in der Objekteigenschaft @code{cause}.
1389 Für einen Notenkopf beispielsweise ist das ein
1390 @rinternals{NoteHead}-Ereignis, und für einen Notenhals
1391 (ein @rinternals{Stem}-Objekt) ist es ein @rinternals{NoteHead}-Objekt.
1393 Hier ist eine Funktion, die mit @code{\applyOutput} benutzt
1394 werden kann; sie macht Notenköpfe auf der Mittellinie unsichtbar:
1396 @lilypond[quote,verbatim,ragged-right]
1397 #(define (blanker grob grob-origin context)
1398 (if (and (memq 'note-head-interface (ly:grob-interfaces grob))
1399 (eq? (ly:grob-property grob 'staff-position) 0))
1400 (set! (ly:grob-property grob 'transparent) #t)))
1403 e4 g8 \applyOutput #'Voice #blanker b d2
1408 @node Scheme-Vorgänge als Eigenschaften
1409 @section Scheme-Vorgänge als Eigenschaften
1410 @translationof Scheme procedures as properties
1412 Eigenschaften (wie Dicke, Richtung usw.) können mit
1413 @code{\override} auf feste Werte gesetzt werden, etwa:
1416 \override Stem #'thickness = #2.0
1419 Eigenschaften können auch auf eine Scheme-Prozedur gesetzt werden:
1421 @lilypond[fragment,verbatim,quote,relative=2]
1422 \override Stem #'thickness = #(lambda (grob)
1423 (if (= UP (ly:grob-property grob 'direction))
1430 In diesem Fall wird die Prozedur ausgeführt, sobal der Wert der
1431 Eigenschaft während das Formatierungsprozesses angefordert wird.
1433 Der größte Teil der Satzmaschinierie funtioniert mit derartigen
1434 Callbacks. Eigenschaften, die üblicherweise Callbacks
1435 benutzen, sind u. A.:
1439 Die Druckfunktion, die eine Ausgabe des Symbols ervorruft
1441 Die Funktion, die die horizontale Position setzt
1443 Die Funktion, die die Breite eines Objekts errechnet
1446 Die Funktionen brauchen immer ein einziges Argument, das der
1449 Wenn Funktionen mit mehreren Argumenten aufgerufen werden müssen,
1450 kann der aktuelle Grob mit einer Grob-Einschließung
1451 eingefügt werden. Hier eine Einstellung aus
1452 @code{AccidentalSuggestion}:
1456 ,(ly:make-simple-closure
1458 ,(ly:make-simple-closure
1459 (list ly:self-alignment-interface::centered-on-x-parent))
1460 ,(ly:make-simple-closure
1461 (list ly:self-alignment-interface::x-aligned-on-self)))))
1465 In diesem Beispiel werden sowohl @code{ly:self-alignment-interface::x-aligned-on-self}
1466 als auch @code{ly:self-alignment-interface::centered-on-x-parent}
1467 mit dem Grob als Argument aufgerufen. Die Resultate werden mit der
1468 @code{+}-Funktion addiert. Um sicherzugehen, dass die Addition
1469 richtig ausgeführt wird, wird das ganze Konstrukt in
1470 @code{ly:make-simple-closure} eingeschlossen.
1472 In der Tat ist die Benutzung einer einzelnen Funktion als
1473 Eigenschaftswert äquivalent zu
1476 (ly:make-simple-closure (ly:make-simple-closure (list @var{proc})))
1480 Das innere @code{ly:make-simple-closure} stellt den Grob als Argument
1481 für @var{proc} zur Verfügung, das äußere stellt sicher, dass das
1482 Resultat der Funktion ausgegeben wird und nicht das
1483 @code{simple-closure}-Objekt.
1486 @node Scheme-Code anstelle von \tweak verwenden
1487 @section Scheme-Code anstelle von @code{ weak} verwenden
1488 @translationof Using Scheme code instead of \tweak
1490 Der hauptsächliche Nachteil von @code{\tweak} ist seine
1491 syntaktische Inflexibilität. Folgender Code beispielsweise
1492 ergibt einen Syntaxfehler:
1495 F = \tweak #'font-size #-3 -\flageolet
1503 Anders gesagt verhält sich @code{\tweak} nicht wie eine Artikulation
1504 und kann auch nicht deren Syntax verwenden: man kann es nicht
1505 mit @code{^} oder @code{_} anfügen.
1507 Durch die Verwendung von Scheme kann dieses Problem umgangen werden.
1508 Der Weg zum Resultat wird gezeigt in
1509 @ref{Artikulationszeichen zu Noten hinzufügen (Beispiel)}, insbesondere
1510 wie @code{\displayMusic} benutzt wird, hilft hier weiter.
1513 F = #(let ((m (make-music 'ArticulationEvent
1514 'articulation-type "flageolet")))
1515 (set! (ly:music-property m 'tweaks)
1516 (acons 'font-size -3
1517 (ly:music-property m 'tweaks)))
1526 In diesem Beispiel werden die @code{tweaks}-Eigenschaften
1527 des Flageolet-Objekts @code{m} (mit @code{make-music} erstellt)
1528 werden mit @code{ly:music-property} ausgelesen, ein neues
1529 Schlüssel-Wert-Paar, um die Schriftgröße zu ändern, wird
1530 der Eigenschaftenliste mithilfe der @code{acons}-Schemefunktion
1531 vorangestellt, und das Resultat wird schließlich mit
1532 @code{set!} zurückgeschrieben. Das letzte Element des
1533 @code{let}-Blocks ist der Wiedergabewert, @code{m}.
1537 @node Schwierige Korrekturen
1538 @section Schwierige Korrekturen
1539 @translationof Difficult tweaks
1541 Hier finden sich einige Klassen an schwierigeren Anpassungen.
1546 Ein Typ der schwierigen Anpassungen ist die Erscheinung von
1547 Strecker-Objekten wie Binde- oder Legatobögen. Zunächst wird
1548 nur eins dieser Objekte erstellt, und sie können mit dem
1549 normalen Mechanismus verändert werden. In einigen Fällen
1550 reichen die Strecker jedoch über Zeilenumbrüche. Wenn das
1551 geschieht, werden diese Objekte geklont. Ein eigenes
1552 Objekt wird für jedes System erstellt, in dem es sich befindet.
1553 Sie sind Klone des originalen Objektes und erben alle
1554 Eigenschaften, auch @code{\override}-Befehle.
1556 Anders gesagt wirkt sich ein @code{\override} immer auf alle
1557 Stücke eines geteilten Streckers aus. Um nur einen Teil eines
1558 Streckers bei einem Zeilenumbruch zu verändern, ist es notwendig,
1559 in den Formatierungsprozess einzugreifen. Das Callback
1560 @code{after-line-breaking} enthält die Schemefunktion, die
1561 aufgerufen wird, nachdem Zeilenumbrüche errechnet worden sind
1562 und die Layout-Objekte über die unterschiedlichen Systeme verteilt
1565 Im folgenden Beispiel wird die Funktion
1566 @code{my-callback} definiert. Diese Funktion
1570 bestimmt, ob das Objekt durch Zeilenumbrüche geteilt ist,
1572 wenn ja, ruft sie alle geteilten Objekte auf,
1574 testet, ob es sich um das letzte der geteilten Objekte handelt,
1576 wenn ja, wird @code{extra-offset} gesetzt.
1579 Diese Funktion muss in @rinternals{Tie} (Bindebogen) installiert
1580 werden, und der letzte Teil eines gebrochenen Bindebogens wird
1581 nach oben verschoben.
1583 @lilypond[quote,verbatim,ragged-right]
1584 #(define (my-callback grob)
1586 ; have we been split?
1587 (orig (ly:grob-original grob))
1589 ; if yes, get the split pieces (our siblings)
1590 (siblings (if (ly:grob? orig)
1591 (ly:spanner-broken-into orig) '() )))
1593 (if (and (>= (length siblings) 2)
1594 (eq? (car (last-pair siblings)) grob))
1595 (ly:grob-set-property! grob 'extra-offset '(-2 . 5)))))
1598 \override Tie #'after-line-breaking =
1605 Wenn man diesen Trick anwendet, sollte das neue @code{after-line-breaking}
1606 auch das alte @code{after-line-breaking}-Callback aufrufen,
1607 wenn es vorhanden ist. Wenn diese Funktion etwa mit
1608 @code{Hairpin} (Crescendo-Klammer) eingesetzt wird, sollte auch
1609 @code{ly:hairpin::after-line-breaking} aufgerufen werden.
1613 Manche Objekte können aus technischen Gründen nicht mit @code{\override}
1614 verändert werden. Beispiele hiervon sind @code{NonMusicalPaperColumn}
1615 und @code{PaperColumn}. Sie können mit der
1616 @code{\overrideProperty}-Funktion geändert werden, die ähnlich wie
1617 @code{\once \override} funktioniert, aber eine andere Syntax einsetzt.
1621 #"Score.NonMusicalPaperColumn" % Grob-Bezeichnung
1622 #'line-break-system-details % Eigenschaftsbezeichnung
1623 #'((next-padding . 20)) % Wert
1626 Es sollte angemerkt werden, dass @code{\override}, wenn man es auf
1627 @code{NonMusicalPaperColumn} und @code{PaperColumn} anwendet, immernoch
1628 innerhalb der @code{\context}-Umgebung funktioniert.