1 @c -*- coding: utf-8; mode: texinfo; -*-
4 Translation of GIT committish: 7b70644b95f383b4281e9ffa146d315d2ada11d3
6 When revising a translation, copy the HEAD committish of the
7 version that you are working on. For details, see the Contributors'
8 Guide, node Updating translation committishes..
13 @c Translators: Till Paala
15 @node Schnittstellen für Programmierer
16 @chapter Schnittstellen für Programmierer
17 @translationof Interfaces for programmers
19 Fortgeschrittene Anpassungen können mithilfe der Programmiersprache
20 Scheme vorgenommen werden. Wenn Sie Scheme nicht kennen, gibt
21 es eine grundlegende Einleitung in LilyPonds
22 @rlearning{Scheme-Übung}.
25 * Musikalische Funktionen::
26 * Schnittstelle für Programmierer::
27 * Komplizierte Funktionen erstellen::
28 * Programmierungsschnittstelle für Textbeschriftungen::
29 * Kontexte für Programmierer::
30 * Scheme-Vorgänge als Eigenschaften::
31 * Scheme-Code anstelle von \tweak verwenden::
32 * Schwierige Korrekturen::
36 @node Musikalische Funktionen
37 @section Musikalische Funktionen
38 @translationof Music functions
40 Dieser Abschnitt behandelt die Erstellung von musikalischen Funktionen
41 innerhalb von LilyPond.
44 * Überblick über musikalische Funktionen::
45 * Einfache Ersetzungsfunktionen::
46 * Paarige Ersetzungsfunktionen::
47 * Mathematik in Funktionen::
49 * Funktionen ohne Argumente::
50 * Überblick über vorhandene musikalische Funktionen::
53 @node Überblick über musikalische Funktionen
54 @subsection Überblick über musikalische Funktionen
55 @translationof Overview of music functions
57 Es ist einfach, eine Funktion zu erstellen, die Variablen
58 im LilyPond-Code ersetzt. Die allgemeine Form derartiger
63 #(define-music-function (parser location @var{var1} @var{var2}...@var{vari}... )
64 (@var{var1-type?} @var{var2-type?}...@var{vari-type?}...)
73 @multitable @columnfractions .33 .66
74 @item @var{vari} @tab die @var{i}te Variable
75 @item @var{vari-type?} @tab die Art der @var{i}ten Variable
76 @item @var{...Noten...} @tab normaler LilyPond-Code, in dem Variablen
77 wie @code{#$var1} usw. benutzt werden.
80 Die folgenden Eingabetypen können als Variablen in einer musikalischen
81 Funktion benutzt werden. Diese Liste ist nicht vollständig -- siehe
82 auch andere Dokumentationen überScheme für weitere Variablenarten.
84 @multitable @columnfractions .33 .66
85 @headitem Eingabetyp @tab @var{vari-type?}-Notation
86 @item Ganzzahl @tab @code{integer?}
87 @item Float (Dezimalzahl) @tab @code{number?}
88 @item Zeichenkette @tab @code{string?}
89 @item Textbeschriftung @tab @code{markup?}
90 @item Musikalischer Ausdruck @tab @code{ly:music?}
91 @item Ein Variablenpaar @tab @code{pair?}
94 Die Argumente @code{parser} und @code{location} sind zwingend erforderlich
95 und werden in einigen fortgeschrittenen Situationen eingesetzt. Das
96 Argument @code{parser} wird benutzt, um auf den Wert einer weiteren
97 LilyPond-Variable zuzugreifen. Das Argument @code{location} wird
98 benutzt, um den @qq{Ursprung} des musikalischen Ausdrucks zu definieren, der von
99 der musikalischen Funktion erzeugt wird. Das hilft, wenn ein
100 Syntaxfehler auftaucht: in solchen Fällen kann LilyPond mitteilen,
101 an welcher Stelle in der Eingabedatei sich der Fehler befindet.
104 @node Einfache Ersetzungsfunktionen
105 @subsection Einfache Ersetzungsfunktionen
106 @translationof Simple substitution functions
108 Hier ist ein einfaches Beispiel:
110 @lilypond[quote,verbatim,ragged-right]
111 padText = #(define-music-function (parser location padding) (number?)
113 \once \override TextScript #'padding = #$padding
121 c4^"piu mosso" fis a g
125 Musikalische Ausdrücke können auch ersetzt werden:
127 @lilypond[quote,verbatim,ragged-right]
128 custosNote = #(define-music-function (parser location note)
131 \once \override Voice.NoteHead #'stencil =
132 #ly:text-interface::print
133 \once \override Voice.NoteHead #'text =
134 \markup \musicglyph #"custodes.mensural.u0"
135 \once \override Voice.Stem #'stencil = ##f
139 { c' d' e' f' \custosNote g' }
142 Mehrere Variablen können benutzt werden:
144 @lilypond[quote,verbatim,ragged-right]
145 tempoPadded = #(define-music-function (parser location padding tempotext)
148 \once \override Score.MetronomeMark #'padding = $padding
149 \tempo \markup { \bold $tempotext }
153 \tempo \markup { "Low tempo" }
155 \tempoPadded #4.0 #"High tempo"
161 @node Paarige Ersetzungsfunktionen
162 @subsection Paarige Ersetzungsfunktionen
163 @translationof Paired substitution functions
165 Einige @code{\override}-Befehle benötigen ein Zahlenpaar
166 (als @code{cons}-Zelle in Scheme bezeichnet). Um beide Zahlen
167 einer Funktion zuzuweisen, kann entweder die Variable @code{pair?}
168 benutzt werden oder die @code{cons} in die musikalische Funktion
174 #(define-music-function (parser location beg-end)
177 \once \override Beam #'positions = #$beg-end
181 \manualBeam #'(3 . 6) c8 d e f
189 @lilypond[quote,verbatim,ragged-right]
191 #(define-music-function (parser location beg end)
194 \once \override Beam #'positions = #(cons $beg $end)
198 \manualBeam #3 #6 c8 d e f
203 @node Mathematik in Funktionen
204 @subsection Mathematik in Funktionen
205 @translationof Mathematics in functions
207 Musikalische Funktionen können neben einfachen Ersetzungen
208 auch Scheme-Programmcode enthalten:
210 @lilypond[quote,verbatim,ragged-right]
211 AltOn = #(define-music-function (parser location mag) (number?)
212 #{ \override Stem #'length = #$(* 7.0 mag)
213 \override NoteHead #'font-size =
214 #$(inexact->exact (* (/ 6.0 (log 2.0)) (log mag))) #})
217 \revert Stem #'length
218 \revert NoteHead #'font-size
221 { c'2 \AltOn #0.5 c'4 c'
222 \AltOn #1.5 c' c' \AltOff c'2 }
226 Dieses Beispiel kann auch umformuliert werden, um musikalische Ausdrücke
229 @lilypond[quote,verbatim,ragged-right]
230 withAlt = #(define-music-function (parser location mag music) (number? ly:music?)
231 #{ \override Stem #'length = #$(* 7.0 mag)
232 \override NoteHead #'font-size =
233 #$(inexact->exact (* (/ 6.0 (log 2.0)) (log mag)))
235 \revert Stem #'length
236 \revert NoteHead #'font-size #})
238 { c'2 \withAlt #0.5 {c'4 c'}
239 \withAlt #1.5 {c' c'} c'2 }
243 @node Leere Funktionen
244 @subsection Leere Funktionen
245 @translationof Void functions
247 Eine musikalische Funktion muss einen musikalischen Ausdruck
248 ausgeben, aber in manchen Fällen müssen Funktionen erstellt werden,
249 die keine Notation enthalten (wie etwa eine Funktion, mit der
250 man @qq{Point and Click} ausschalten kann). Um das vornehmen zu
251 können, wird ein @code{leere}r musikalischer Ausdruck ausgegeben.
253 Das ist der Grund, warum die Form, die ausgegeben wird,
254 @code{(make-music ...)} heißt. Wird die Eigenschaft
255 @code{'void} (engl. für @qq{leer}) auf @code{#t} gesetzt, wird der
256 Parser angewiesen, den ausgegebenen musikalischen Ausdruck zu ignorieren.
257 Der maßgebliche Teil der @code{'void}-Funktion ist also die Verarbeitung,
258 die die Funktion vornimmt, nicht der musikalische Ausdruck, der ausgegeben
263 #(define-music-function (parser location) ()
264 (ly:set-option 'point-and-click #f)
265 (make-music 'SequentialMusic 'void #t))
267 \noPointAndClick % disable point and click
271 @node Funktionen ohne Argumente
272 @subsection Funktionen ohne Argumente
273 @translationof Functions without arguments
275 In den meisten Fällen sollten Funktionen ohne Argumente mit einer
276 Variable notiert werden:
279 dolce = \markup@{ \italic \bold dolce @}
282 In einigen wenigen Fällen kann es aber auch sinnvoll sein, eine
283 musikalische Funktion ohne Argumente zu erstellen:
287 #(define-music-function (parser location) ()
288 (if (eq? #t (ly:get-option 'display-bar-numbers))
289 #@{ \once \override Score.BarNumber #'break-visibility = ##f #@}
293 Damit auch wirklich Taktzahlen angezeigt werden, wo die
294 Funktion eingesetzt wurde, muss @command{lilypond} mit
298 lilypond -d display-bar-numbers Dateiname.ly
305 @node Überblick über vorhandene musikalische Funktionen
306 @subsection Überblick über vorhandene musikalische Funktionen
307 @translationof Overview of available music functions
309 @c fixme ; this should be move somewhere else?
310 Die folgenden Befehle sind musikalische Funktionen:
312 @include identifiers.tely
316 @node Schnittstelle für Programmierer
317 @section Schnittstelle für Programmierer
318 @translationof Programmer interfaces
320 Dieser Abschnitt zeigt, wie LilyPond und
321 Scheme gemischt werden können.
324 * Eingabevariablen und Scheme::
325 * Interne Repräsentation der Musik::
329 @node Eingabevariablen und Scheme
330 @subsection Eingabevariablen und Scheme
331 @translationof Input variables and Scheme
333 Das Eingabeformat unterstützt die Notation von Variablen: im
334 folgenden Beispiel wird ein musikalischer Ausdruck einer Variable
335 mit der Bezeichnung @code{traLaLa} zugewiesen:
338 traLaLa = @{ c'4 d'4 @}
341 Der Geltungsbereich von Variablen ist beschränkt: im folgenden
342 Beispiel enthält die @code{\layout}-Umgebung auch eine
343 @code{traLaLa}-vVariable, die unabhängig von der äußeren
344 @code{\traLaLa}-Variable ist:
347 traLaLa = @{ c'4 d'4 @}
348 \layout @{ traLaLa = 1.0 @}
351 Grundsätzlich ist jede Eingabedatei ein Geltungsbereich, und
352 alle @code{\header}-, @code{\midi}- und @code{\layout}-Umgebungen
353 sind Geltungsbereiche, die unterhalb des globalen Geltungsbereiches
356 Sowohl Variablen als auch Geltungsbereiche sind in Form des
357 GUILE-Modulsystems implementiert. Ein anonymes Scheme-Modul
358 wird an jeden Geltunsbereich angehängt. Eine Zuweisung der form
361 traLaLa = @{ c'4 d'4 @}
365 wird intern in die Scheme-Definition
368 (define traLaLa @var{Scheme-Wert von `@code{... }'})
374 Das bedeutet, dass Eingabe- und Scheme-Variablen frei vermischt
375 werden können. Im nächsten Beispiel wird ein Notenfragment in
376 der Variable @code{traLaLa} gespeichert und mithilfe von Schme
377 dupliziert. Das Ergebnis wird in eine @code{\score}-Umgebung
378 mit der zweiten Variable @code{twice} integriert:
381 traLaLa = { c'4 d'4 }
383 %% dummy action to deal with parser lookahead
384 #(display "this needs to be here, sorry!")
386 #(define newLa (map ly:music-deep-copy
387 (list traLaLa traLaLa)))
389 (make-sequential-music newLa))
394 In diesem Beispiel geschieht die Zuweisung, nachdem der Parser
395 festgestellt hat, dass nichts interessantes mehr nach
396 @code{traLaLa = @{ ... @}} vorkommt. Ohne die Pseudovariable
397 in dem Beispiel würde die @code{newLa}-Devinition ausgeführt
398 werden, bevor @code{traLaLa} definiert ist, was zu einem
399 Syntax-Fehler führen würde.
401 Das obige Beispiel zeigt, wie man musikalische Ausdrücke
402 von der Eingabe in den Scheme-Interpretierer @qq{exportieren}
403 kann. Es geht auch in die andere Richtung. Indem man einen
404 Scheme-Wert in die Funktion @code{ly:export} einpackt, wird
405 der Scheme-Wert interpretiert als ob er in LilyPond-Syntax
406 notiert worden wäre. Anstatt @code{\twice} zu definieren,
407 hätte man also auch schreiben können:
411 @{ #(ly:export (make-sequential-music (list newLa))) @}
414 Scheme-Code wird sofort ausgewertet, wenn der Parser darauf
415 stößt. Um Scheme-Code in einem Makro zu definieren (das dann
416 erst später aufgerufen werden soll), müssen leere Funktionen
417 benutzt werden (siehe @ref{Leere Funktionen}) oder das Folgende:
421 (ly:set-option 'point-and-click #f))
430 Scheme- und LilyPond-Variablen können im LilyPond-Modus mit der
431 @code{--safe}-Option nicht vermischt werden.
434 @node Interne Repräsentation der Musik
435 @subsection Interne Repräsentation der Musik
436 @translationof Internal music representation
438 Wenn ein musikalischer Ausdruck ausgewertet wird, wird er in eine
439 Anzahl von musikalischen Scheme-Objekten konvertiert. Die Eigenschaft, die ein
440 musikalisches Objekt definiert, ist, dass es Zeit einnimmt. Zeit ist
441 eine rationale Zahl, die die Länge eines Stückes in ganzen Noten
444 Ein musikalisches Objekt hat drei Typusarten:
447 musikalische Bezeichnung: Jeder musikalische Ausdruck hat eine Bezeichnung.
448 Eine Note beispielsweise führt zu einem @rinternals{NoteEvent} und
449 @code{\simultaneous} führt zu @rinternals{SimultaneousMusic}. Eine Liste
450 aller möglichen Ausdrücke findet sich in der Referenz der Interna, unter
451 @rinternals{Music expressions}.
454 @q{Typ} oder Schnittstelle: Jede musikalische Bezeichnung hat mehrere
455 @qq{Typen} oder Schnittstellten, beispielsweise ist eine Note ein
456 @code{event}, ober sie ist auch ein @code{note-event}, ein
457 @code{rhythmic-event} und ein @code{melodic-event}. Alle diese
458 Notationsklassen finden sich in der Referenz der Interna unter
459 @rinternals{Music classes}.
462 C++-Objekt: Jedes musikalische Objekt wird von einem Objekt der
463 C++-Klasse @code{Music} repräsentiert.
466 Die eigentlich Information eines musikalischen Ausdrucks ist in
467 Eigenschaften gespeichert. Ein @rinternals{NoteEvent} hat zum
468 Beispiel @code{pitch}- und @code{duration}-Eigenschaften, die
469 die Tonhöhe und die Dauer dieser Note speichern. Eine Liste aller
470 verfügbaren Eigenschaften findet sich in der Referenz der Interna unter
471 @rinternals{Music properties}.
473 Ein zusammengesetzter musikalischer Ausdruck ist ein musikalisches
474 Objekt, das andere Objekte in seinen Eigenschaften enthält. Eine Liste
475 der Objekte kann in der @code{elements}-Eigenschaft eines
476 musikalischen Objektes gespeichert werden, oder ein einziges
477 @qq{Kind}-Objekt in der @code{element}-Eigenschaft. Sa hat etwa
478 @rinternals{SequentialMusic} seine @qq{Kinder} in @code{elements},
479 und @rinternals{GraceMusic} hat sein einziges Argument in
480 @code{element}. Der Hauptteil einer Wiederholung wird in der
481 @code{element}-Eigenschaft von @rinternals{RepeatedMusic} gespeichert,
482 und die Alternativen in @code{elements}.
486 @node Komplizierte Funktionen erstellen
487 @section Komplizierte Funktionen erstellen
488 @translationof Building complicated functions
490 Dieser Abschnitt zeigt, wie man Information zusammensucht,
491 um komplizierte musikalische Funktionen zu erstellen.
494 * Musikalische Funktionen darstellen::
495 * Eigenschaften von Musikobjekten::
496 * Verdoppelung einer Note mit Bindebögen (Beispiel)::
497 * Artikulationszeichen zu Noten hinzufügen (Beispiel)::
501 @node Musikalische Funktionen darstellen
502 @subsection Musikalische Funktionen darstellen
503 @translationof Displaying music expressions
505 @cindex interne Speicherung
506 @cindex Musikausdrücke anzeigen
507 @cindex Anzeigen von Musikausdrücken
509 @funindex displayMusic
510 @funindex \displayMusic
512 Wenn man eine musikalische Funktion erstellt, ist es oft
513 hilfreich sich anzuschauen, wie musikalische Funktionen
514 intern gespeichert werden. Das kann mit der Funktion
515 @code{\displayMusic} erreicht werden:
519 \displayMusic @{ c'4\f @}
536 (ly:make-duration 2 0 1 1)
538 (ly:make-pitch 0 0 0))
540 'AbsoluteDynamicEvent
545 Normalerweise gibt LilyPond diese Ausgabe auf der Konsole mit
546 allen anderen Nachrichten aus. Um die wichtigen Nachrichten
547 in einer Datei zu speichern, kann die Ausgabe in eine Datei
551 lilypond file.ly >display.txt
554 Mit etwas Umformatierung ist die gleiche Information sehr viel
558 (make-music 'SequentialMusic
559 'elements (list (make-music 'EventChord
560 'elements (list (make-music 'NoteEvent
561 'duration (ly:make-duration 2 0 1 1)
562 'pitch (ly:make-pitch 0 0 0))
563 (make-music 'AbsoluteDynamicEvent
567 Eine musikalische @code{@{ ... @}}-Sequenz hat die Bezeichnung
568 @code{SequentialMusic} und ihre inneren Ausdrücke werden als
569 Liste in seiner @code{'elements}-Eigenschaft gespeichert. Eine
570 Note ist als als ein @code{EventChord}-Ausdruck dargestellt,
571 der ein @code{NoteEvent}-Objekt (welches Dauer und
572 Tonhöhe speichert) und zusätzliche Information enthält (in
573 diesem Fall ein @code{AbsoluteDynamicEvent} mit einer
574 @code{"f"}-Text-Eigenschaft.
577 @node Eigenschaften von Musikobjekten
578 @subsection Eigenschaften von Musikobjekten
579 @translationof Music properties
581 Das @code{NoteEvent}-Objekt ist das erste Objekt der
582 @code{'elements}-Eigenschaft von @code{someNote}.
586 \displayMusic \someNote
594 (ly:make-duration 2 0 1 1)
596 (ly:make-pitch 0 0 0))))
599 Die @code{display-scheme-music}-Funktion ist die Funktion, die von
600 @code{\displayMusic} eingesetzt wird, um die Scheme-Repräsentation
601 eines musikalischen Ausdrucks anzuzeigen.
604 #(display-scheme-music (first (ly:music-property someNote 'elements)))
609 (ly:make-duration 2 0 1 1)
611 (ly:make-pitch 0 0 0))
614 Danach wird die Tonhöhe der Note von der @code{'pitch}-Eigenschaft
615 des @code{NoteEvent}-Objektes gelesen:
618 #(display-scheme-music
619 (ly:music-property (first (ly:music-property someNote 'elements))
622 (ly:make-pitch 0 0 0)
625 Die Tonhöhe einer Note kann geändert werden, indem man diese
626 @code{'pitch}-Eigenschaft umdefiniert:
628 @funindex \displayLilyMusic
629 @funindex displayLilyMusic
632 #(set! (ly:music-property (first (ly:music-property someNote 'elements))
634 (ly:make-pitch 0 1 0)) ;; Die Tonhöhen auf d' verändern.
635 \displayLilyMusic \someNote
641 @node Verdoppelung einer Note mit Bindebögen (Beispiel)
642 @subsection Verdoppelung einer Note mit Bindebögen (Beispiel)
643 @translationof Doubling a note with slurs (example)
645 In diesem Abschnitt soll gezeigt, werden, wie man eine
646 Funktion erstellt, die eine Eingabe wie @code{a}
647 nach @code{a( a)} umdefiniert. Dazu wird zuerst die
648 interne Repräsentation der Musik betrachtet, die
649 das Endergebnis darstellt:
652 \displayMusic@{ a'( a') @}
663 (ly:make-duration 2 0 1 1)
665 (ly:make-pitch 0 5 0))
676 (ly:make-duration 2 0 1 1)
678 (ly:make-pitch 0 5 0))
685 Eine schlechte Nachricht ist, dass die
686 @code{SlurEvent}-Ausdrücke @qq{innerhalb}
687 der Noten (bzw. innerhalb der
688 @code{EventChord}-Ausdrücke) hinzugefügt werden müssen.
690 Jetzt folgt eine Betrachtung der Eingabe:
702 (ly:make-duration 2 0 1 1)
704 (ly:make-pitch 0 5 0))))))
707 In der gewünschten Funktion muss also dieser Ausdruck
708 kopiert werden (sodass zwei Noten vorhanden sind, die
709 eine Sequenz bilden), dann müssen @code{SlurEvent}
710 zu der @code{'elements}-Eigenschaft jeder Noten hinzugefügt
711 werden, und schließlich muss eine @code{SequentialMusic}
712 mit den beiden @code{EventChords} erstellt werden.
715 doubleSlur = #(define-music-function (parser location note) (ly:music?)
716 "Return: @{ note ( note ) @}.
717 `note' is supposed to be an EventChord."
718 (let ((note2 (ly:music-deep-copy note)))
719 (set! (ly:music-property note 'elements)
720 (cons (make-music 'SlurEvent 'span-direction -1)
721 (ly:music-property note 'elements)))
722 (set! (ly:music-property note2 'elements)
723 (cons (make-music 'SlurEvent 'span-direction 1)
724 (ly:music-property note2 'elements)))
725 (make-music 'SequentialMusic 'elements (list note note2))))
729 @node Artikulationszeichen zu Noten hinzufügen (Beispiel)
730 @subsection Artikulationszeichen zu Noten hinzufügen (Beispiel)
731 @translationof Adding articulation to notes (example)
733 Am einfachsten können Artikulationszeichen zu Noten
734 hinzugefügt werden, indem man zwei musikalische Funktionen
735 in einen Kontext einfügt, wie erklärt in
736 @ref{Kontexte erstellen}. Hier soll jetzt eine musikalische
737 Funktion entwickelt werden, die das vornimmt.
739 Eine @code{$variable} innerhalb von @code{#@{...#@}} ist das
740 gleiche wie die normale Befehlsform @code{\variable} in
741 üblicher LilyPond-Notation. Es ist bekannt dass
748 in LilyPond nicht funktioniert. Das Problem könnte vermieden
749 werden, indem das Artikulationszeichen an eine Pseudonote
753 @{ << \music s1*0-.-> @}
757 aber in diesem Beispiel soll gezeigt werden, wie man das in
758 Scheme vornimmt. Zunächst wird die Eingabe und die gewünschte
771 (ly:make-duration 2 0 1 1)
773 (ly:make-pitch -1 0 0))))
784 (ly:make-duration 2 0 1 1)
786 (ly:make-pitch -1 0 0))
793 Dabei ist zu sehen, dass eine Note (@code{c4}) als @code{EventChord}
794 repräsentiert ist, mit einem @code{NoteEvent}-Ausdruck in ihrer
795 Elementenliste. Um eine Marcato-Artikulation hinzuzufügen, muss
796 ein @code{ArticulationEvent}-Ausdrcuk zu der Elementeigenschaft
797 des @code{EventChord}-Ausdrucks hinzugefügt werden.
799 Um diese Funktion zu bauen, wird folgerndermaßen begonnen:
802 (define (add-marcato event-chord)
803 "Add a marcato ArticulationEvent to the elements of `event-chord',
804 which is supposed to be an EventChord expression."
805 (let ((result-event-chord (ly:music-deep-copy event-chord)))
806 (set! (ly:music-property result-event-chord 'elements)
807 (cons (make-music 'ArticulationEvent
808 'articulation-type "marcato")
809 (ly:music-property result-event-chord 'elements)))
813 Die erste Zeile definiert eine Funktion in Scheme: Die Bezeichnung
814 der Funktion ist @code{add-marcato} und sie hat eine Variable
815 mit der Bezeichnung @code{event-chord}. In Scheme geht der Typ
816 einer Variable oft direkt aus der Bezeichnung hervor (das ist auch
817 eine gute Methode für andere Programmiersprachen).
824 ist eine (englische) Beschreibung, was diese Funktion tut. Sie ist
825 nicht unbedingt notwendig, aber genauso wie klare Variablen-Bezeichnungen
826 ist auch das eine gute Methode.
829 (let ((result-event-chord (ly:music-deep-copy event-chord)))
832 @code{let} wird benutzt, um die lokalen Variablen zu definieren. Hier
833 wird eine lokale Variable benutzt: @code{result-event-chord}. Sie erhält
834 den Wert @code{(ly:music-deep-copy event-chord)}. @code{ly:music-deep-copy}
835 ist eine LilyPond-spezifische Funktion, die wie alle Funktionen mit dem
836 Präfix @code{ly:} versehen ist. Sie wird benutzt, um eine Kopie eines
837 musikalischen Ausdrucks anzufertigen. Hier wird @code{event-chord}
838 (der Parameter der Funktion) kopiert. Die Funktion soll ja nur ein
839 Artikulationszeichen an einen @code{EventChord} gehängt werden, deshalb ist es besser,
840 den @code{EventChord}, der als Argument gegeben wurde, nicht zu
841 verändern, weil er woanders benutzt werden könnte.
843 Jetzt gibt es @code{result-event-chord}, wobei es sich um einen
844 @code{NoteEventChord}-Ausdruck handelt, welcher gleichzeigt eine Kopie
845 von @code{event-chord} ist. Das Makro wird seiner Eigenschaftsliste
849 (set! place new-value)
852 Was in diesem Fall @qq{gesetzt} werden soll (@qq{place}) ist die
853 @q{elements}-Eigenschaft des @code{result-event-chord}-Ausdrucks.
856 (ly:music-property result-event-chord 'elements)
859 @code{ly:music-property} ist die Funktion, mit der musikalische
860 Eigenschaften erreicht werden können (die @code{'elements},
861 @code{'duration}, @code{'pitch} usw., die in der Ausgabe von
862 @code{\displayMusic} weiter oben angezeigt werden). Der neue
863 Wert ist, was ehemals die Elemtneigenschaft war, mit einem
864 zusätzlichen Element: dem @code{ArticulationEvent}-Ausdruck,
865 der aus der Ausgabe von
866 @code{\displayMusic} kopiert werden kann:
869 (cons (make-music 'ArticulationEvent
870 'articulation-type "marcato")
871 (ly:music-property result-event-chord 'elements))
874 @code{cons} wird benutzt, um ein Element zu einer Liste hinzuzufügen,
875 ohne dass die originale Liste verändert wird. Das ist es, was die
876 Funktion tun soll: die gleiche Liste, aber mit dem neuen
877 @code{ArticulationEvent}-Ausdruck. Die Reihenfolge innerhalb
878 der Elementeeigenschaft ist hier nicht relevant.
880 Wenn schließlich die Marcato-Artikulation zu der entsprechenden
881 @code{elements}-Eigenschaft hinzuzugefügt ist, kann
882 @code{result-event-chord} ausgegeben werden, darum die letzte Zeile
885 Jetzt wird die @code{add-marcato}-Funktion in eine musikalische
886 Funktion umgewandelt:
889 addMarcato = #(define-music-function (parser location event-chord)
891 "Add a marcato ArticulationEvent to the elements of `event-chord',
892 which is supposed to be an EventChord expression."
893 (let ((result-event-chord (ly:music-deep-copy event-chord)))
894 (set! (ly:music-property result-event-chord 'elements)
895 (cons (make-music 'ArticulationEvent
896 'articulation-type "marcato")
897 (ly:music-property result-event-chord 'elements)))
901 Eine Überprüfung, dass die Funktion richtig arbeitet, geschieht
905 \displayMusic \addMarcato c4
909 @node Programmierungsschnittstelle für Textbeschriftungen
910 @section Programmierungsschnittstelle für Textbeschriftungen
911 @translationof Markup programmer interface
913 Textbeschriftungselemente sind als besondere Scheme-Funktionen
914 definiert, die ein Stencil-Objekt erstellen, dem eine Anzahl
915 an Argumenten übergeben wird.
918 * Beschriftungskonstruktionen in Scheme::
919 * Wie Beschriftungen intern funktionieren::
920 * Neue Definitionen von Beschriftungsbefehlen::
921 * Neue Definitionen von Beschriftungsbefehlen für Listen::
925 @node Beschriftungskonstruktionen in Scheme
926 @subsection Beschriftungskonstruktionen in Scheme
927 @translationof Markup construction in Scheme
929 @cindex Textbeschriftungsbefehle, definieren
930 @cindex Textbeschriftung, eigene Befehle
931 @cindex eigene Befehle, Textbeschriftung
932 @cindex markup, eigene Befehle
933 @cindex Befehle definieren, Textbeschriftung
935 Das @code{markup}-(Textbeschriftungs)Makro erstellt Textbeschriftungs-Ausdrücke
936 in Scheme, wobei eine LilyPond-artige Syntax benutzt wird. Beispielsweise
940 (markup #:column (#:line (#:bold #:italic "hello" #:raise 0.4 "world")
941 #:larger #:line ("foo" "bar" "baz")))
948 \markup \column @{ \line @{ \bold \italic "hello" \raise #0.4 "world" @}
949 \larger \line @{ foo bar baz @} @}
953 Dieses Beispiel zeigt die hauptsächlichen Übersetzungsregeln
954 zwischen normaler Textbeschriftungssyntax von LilyPond und der
955 Textbeschriftungssyntax in Scheme.
958 @multitable @columnfractions .3 .3
959 @item @b{LilyPond} @tab @b{Scheme}
960 @item @code{\markup Text1} @tab @code{(markup Text1)}
961 @item @code{\markup @{ Text1 Text2 ... @}} @tab
962 @code{(markup Text1 Text2 ... )}
963 @item @code{\Befehl} @tab @code{#:Befehl}
964 @item @code{\Variable} @tab @code{Variable}
965 @item @code{\center-column @{ ... @}} @tab @code{#:center-column ( ... )}
966 @item @code{Zeichenkette} @tab @code{"Zeichenkette"}
967 @item @code{#scheme-arg} @tab @code{scheme-arg}
971 Die gesamte Scheme-Sprache ist innerhalb des @code{markup}-Makros
972 zugänglich. Man kann also beispielsweise Funktionen innerhalb
973 eines @code{markup} aufrufen, um Zeichenketten zu manipulieren.
974 Das ist nützlich, wenn neue Beschriftungsbefehle definiert werden
976 @ref{Neue Definitionen von Beschriftungsbefehlen}).
981 Das Beschriftungslistenargument von Befehlen wie @code{#:line},
982 @code{#:center} und @code{#:column} kann keine Variable oder
983 das Resultat eines Funktionsaufrufen sein.
986 (markup #:line (Funktion-die-Textbeschriftung-ausgibt))
990 ist ungültig. Man sollte anstatt dessen die Funktionen
991 @code{make-line-markup}, @code{make-center-markup} oder
992 @code{make-column-markup} benutzen:
995 (markup (make-line-markup (Funktion-die-Textbeschriftung-ausgibt)))
999 @node Wie Beschriftungen intern funktionieren
1000 @subsection Wie Beschriftungen intern funktionieren
1001 @translationof How markups work internally
1003 In einer Textbeschriftung wie
1006 \raise #0.5 "Textbeispiel"
1010 ist @code{\raise} unter der Haube durch die @code{raise-markup}-Funktion
1011 repräsentiert. Der Beschriftungsausdruck wird gespeichert als
1014 (list raise-markup 0.5 (list simple-markup "Textbeispiel"))
1017 Wenn die Beschriftung in druckbare Objekte (Stencils) umgewandelt ist,
1018 wir die @code{raise-markup}-Funktion folgendermaßen aufgerufen:
1022 @var{\layout object}
1023 @var{Liste der Eigenschafts-alists}
1025 @var{die "Textbeispiel"-Beschriftung})
1028 Die @code{raise-markup}-Funktion erstellt zunächt den Stencil für die
1029 @code{Textbeispiel}-Beschriftung und verschiebt dann diesen Stencil
1030 um 0.5 Notenlinienzwischenräume nach oben. Das ist ein einfaches
1031 Beispiel. Weitere, kompliziertere Beispiele finden sich nachfolgend
1032 in diesem Abschnitt und in der Datei
1033 @file{scm/@/define@/-markup@/-commands@/.scm}.
1036 @node Neue Definitionen von Beschriftungsbefehlen
1037 @subsection Neue Definitionen von Beschriftungsbefehlen
1038 @translationof New markup command definition
1040 Neue Textbeschriftungsbefehle können mit dem
1041 @code{define-markup-command}-Scheme-Makro definiert werden.
1044 (define-markup-command (@var{befehl-bezeichnung} @var{layout} @var{props} @var{arg1} @var{arg2} ...)
1045 (@var{arg1-type?} @var{arg2-type?} ...)
1053 @var{i}te Befehlsargument
1055 eine Eigenschaft für das @var{i}te Argument
1057 die @q{layout}-Definition
1059 eine Liste an alists, in der alle aktiven Eigenschaften enthalten sind
1062 Als einfaches Beispiel soll gezeigt werden, wie man einen
1063 @code{\smallcaps}-Befehl hinzufügen kann, der die Kapitälchen
1064 für die Schriftzeichen auswählt. Normalerweise würde man Kapitälchen
1065 folgendermaßen auswählen:
1068 \markup @{ \override #'(font-shape . caps) Text-in-Kapitälchen @}
1072 Damit wird die Kapitälchenschriftart ausgewählt, indem die
1073 @code{font-shape}-Eigesnchaft auf @code{#'caps} gesetzt wird,
1074 während @code{Text-in-caps} interpretiert wird.
1076 Damit diese Funkion als @code{\smallcaps}-Befehl zur Verfügung
1077 gestellt werden kann, muss eine Funktion mit @code{define-markup-command}
1078 definiert werden. Der Befehl braucht ein Argument vom Typ @code{markup}.
1079 Darum sollte der Beginn der Funktion lauten:
1082 (define-markup-command (smallcaps layout props argument) (markup?)
1087 Was jetzt folgt, ist der eigentliche Inhalt des Befehls: das
1088 @code{argument} soll als Beschriftung (markup) interpretiert werden,
1092 (interpret-markup layout @dots{} argument)
1096 Diese Interpretation sollte @code{'(font-shape . caps)} zu den
1097 aktiven Eigenschaften hinzufügen, weshalb wir das Folgende anstelle
1098 der @dots{} in dem Beispiel einfügen:
1101 (cons (list '(font-shape . caps) ) props)
1105 Die Variable @code{props} ist eine Liste an alists, und mit @code{cons}
1106 wird ihr eine zusätzliche Einstellung hinzugefügt.
1108 Man könnte sich auch vorstellen, dass ein Rezitativ einer Oper
1109 gesetzt werden soll, und ein Befehl wäre sehr bequem, mit dem
1110 man die Namen der Charaktere auf eine eigene Art darstellen könnte.
1111 Namen sollen in Kapitälchen gesetzt werden und etwas nach links und
1112 oben verschoben werden. Man kann also einen @code{\character}-Befehl
1113 definieren, der die nötige Verschiebung berücksichtigt und
1114 den neuen @code{\smallcaps}-Befehl einsetzt:
1117 #(define-markup-command (character layout props name) (string?)
1118 "Print the character name in small caps, translated to the left and
1119 top. Syntax: \\character #\"name\""
1120 (interpret-markup layout props
1121 (markup #:hspace 0 #:translate (cons -3 1) #:smallcaps name)))
1124 Hier ist eine Komplikation, die erklärt werden muss: Text über oder
1125 unter dem Notensystem wird vertikal verschoben um in einem bestimmten
1126 Abstand von dem System und den Noten zu sein (das wird als @qq{padding}
1127 bezeichnet). Um sicherzugehen, dass dieser Mechanismus nicht die
1128 vertikale Verschiebung von @code{#:translate} annulliert, wird
1129 die leere Zeichenkette (@code{#:hspace 0}) vor den zu verschiebenden
1130 Text gesetzt. Das @code{#:hspace 0} wird jetzt also über die Noten
1131 gesetzt und @code{name} dann relativ zu der leeren Zeichenkette
1132 verschoben. Im Endeffekt wird der Text nach links oben verschoben.
1134 Das Resultat sieht folgendermaßen aus:
1138 c''^\markup \character #"Cleopatra"
1139 e'^\markup \character #"Giulio Cesare"
1143 @lilypond[quote,ragged-right]
1144 #(define-markup-command (smallcaps layout props str) (string?)
1145 "Print the string argument in small caps. Syntax: \\smallcaps #\"string\""
1146 (interpret-markup layout props
1149 (if (= (string-length s) 0)
1151 (markup #:large (string-upcase (substring s 0 1))
1152 #:translate (cons -0.6 0)
1153 #:tiny (string-upcase (substring s 1)))))
1154 (string-split str #\Space)))))
1156 #(define-markup-command (character layout props name) (string?)
1157 "Print the character name in small caps, translated to the left and
1158 top. Syntax: \\character #\"name\""
1159 (interpret-markup layout props
1160 (markup #:hspace 0 #:translate (cons -3 1) #:smallcaps name)))
1163 c''^\markup \character #"Cleopatra" c'' c'' c''
1164 e'^\markup \character #"Giulio Cesare" e' e' e'
1168 In diesen Befehlen wurden Kapitälchen eingesetzt, aber es kann
1169 vorkommen, dass die Schriftart keine Kapitälchen zur Verfügung
1170 stellt. In diesem Fall können die Kapitälchen nachempfunden
1171 werden, indem man Großbuchstaben setzt, deren Anfangsbuchstabe
1172 etwas größer gesetzt wird:
1175 #(define-markup-command (smallcaps layout props str) (string?)
1176 "Print the string argument in small caps."
1177 (interpret-markup layout props
1180 (if (= (string-length s) 0)
1182 (markup #:large (string-upcase (substring s 0 1))
1183 #:translate (cons -0.6 0)
1184 #:tiny (string-upcase (substring s 1)))))
1185 (string-split str #\Space)))))
1188 Der @code{smallcaps}-Befehl spaltet die Argumente zuerst in
1189 Einzelstücke auf, die von Leerzeichen getrennt sind
1190 (@code{(string-split str #\Space)}); für jedes Einzelstück
1191 wird dann eine Beschriftung aufgebaut, deren erster Buchstabe
1192 vergrößert wird und als Versalbuchstabe gesetzt wird
1193 (@code{#:large (string-upcase (substring s 0 1))}), und eine
1194 zweite Versalbuchstaben gesetzt werden
1195 (@code{#:tiny (string-upcase (substring s 1))}). Wenn
1196 LilyPond ein Leerzeichen zwischen Beschriftungen einer Zeile
1197 entdeckt, wird die zweite Beschriftung nach links verschoben
1198 (@code{#:translate (cons -0.6 0) ...}). Dann werden die
1199 Beschriftungen für jedes Einzelstück in eine Zeile gesetzt
1200 @code{(make-line-markup ...)}. Schließlich wird die resultierende
1201 Beschriftung an die @code{interpret-markup}-Funktion zusammen
1202 mit den Argumenten @code{layout} und @code{props} weitergereicht.
1204 Achtung: ist gibt keinen internen Befehl @code{\smallCaps}, der
1205 benutzt werden kann, um Text in Kapitälchen zu setzen. Siehe auch
1206 @ref{Text markup commands}.
1210 Im Moment sind die möglichen Kombinationen von Argumenten (nach den
1211 Standardargumenten @var{layout} und @var{props}), die mit
1212 @code{define-markup-command} definiert werden, wie folgt
1216 @item (kein Argument)
1219 @itemx @var{markup markup}
1221 @itemx @var{scm markup}
1222 @itemx @var{scm scm}
1223 @itemx @var{scm scm markup}
1224 @itemx @var{scm scm markup markup}
1225 @itemx @var{scm markup markup}
1226 @itemx @var{scm scm scm}
1230 Hier stellt @var{scm} native Scheme-Datentypen dar wie
1231 @q{number} oder @q{string}.
1233 Es ist beispielsweise nicht möglich, einen Beschriftungsbefehl
1234 @code{foo} mit vier Argumenten in folgender Weise zu nutzen:
1237 #(define-markup-command (foo layout props
1238 num1 str1 num2 str2)
1239 (number? string? number? string?)
1244 Wenn es folgendermaßen eingesetzt wird:
1247 \markup \foo #1 #"bar" #2 #"baz"
1250 @cindex Scheme signature
1251 @cindex Signatur, Scheme
1253 beschwert sich @command{lilypond}, dass @code{foo} wegen einer ungekannten
1254 Scheme Signatur nicht analysiert werden kann.
1257 @node Neue Definitionen von Beschriftungsbefehlen für Listen
1258 @subsection Neue Definitionen von Beschriftungsbefehlen für Listen
1259 @translationof New markup list command definition
1261 Beschriftungslistenbefehle können mit dem Scheme-Makro
1262 @code{define-markup-list-command} definiert werden, welches
1263 sich ähnlich verhält wie das
1264 @code{define-markup-command}-Makro, das schon beschrieben
1265 wurde in @ref{Neue Definitionen von Beschriftungsbefehlen}. Ein Unterschied
1266 ist, dass bei diesem Listen-Makro eine ganze Liste an
1267 Stecils ausgegeben wird.
1269 Im folgenden Beispiel wird ein @code{\paragraph}-Beschriftungslistenbefehl
1270 definiert, welcher eine Liste von Zeilen im Blocksatz ausgibt, von
1271 denen die erste Zeile eingerückt ist. Der Einzug wird aus dem
1272 @code{props}-Argument entnommen.
1275 #(define-markup-list-command (paragraph layout props args) (markup-list?)
1276 (let ((indent (chain-assoc-get 'par-indent props 2)))
1277 (interpret-markup-list layout props
1278 (make-justified-lines-markup-list (cons (make-hspace-markup indent)
1282 Neben den üblichen @code{layout} und @code{props}-Argumenten, nimmt der
1283 @code{paragraph}-Beschriftungslistenbefehl als Argument eine Beschriftungsliste,
1284 die @code{args} genannt wird. Das Prädikat für Beschriftungslisten ist
1285 @code{markup-list?}.
1287 Zuerst errechnet die Funktion die Breite des Einzugs, eine Eigenschaft
1288 mit der Bezeichnung @code{par-indent} anhand der Eigenschaftsliste
1289 @code{props}. Wenn die Eigenschaft nicht gefunden wird, ist der
1290 Standardwert @code{2}. Danach wird eine Liste von Zeilen im Blocksatz
1291 erstellt, wobei die @code{make-justified-lines-markup-list}-Funktion
1292 eingesetzt wird, die verwandt ist mit dem eingebauten
1293 @code{\justified-lines}-Beschriftungslistenbefehl. Horizontaler
1294 Platz wird zu Beginn eingefügt mit der @code{make-hspace-markup}-Funktion.
1295 Zuletzt wird die Beschriftungsliste ausgewertet durch die
1296 @code{interpret-markup-list}-Funktion.
1298 Dieser neue Beschriftungslistenbefehl kann wie folgt benutzt werden:
1303 Die Kunst des Notensatzes wird auch als \italic @{Notenstich@} bezeichnet. Dieser
1304 Begriff stammt aus dem traditionellen Notendruck. Noch bis vor etwa
1305 20 Jahren wurden Noten erstellt, indem man sie in eine Zink- oder
1306 Zinnplatte schnitt oder mit Stempeln schlug.
1308 \override-lines #'(par-indent . 4) \paragraph @{
1309 Diese Platte wurde dann mit Druckerschwärze versehen, so dass sie
1310 in den geschnittenen und gestempelten Vertiefungen blieb. Diese
1311 Vertiefungen schwärzten dann ein auf die Platte gelegtes Papier.
1312 Das Gravieren wurde vollständig von Hand erledigt.
1319 @node Kontexte für Programmierer
1320 @section Kontexte für Programmierer
1321 @translationof Contexts for programmers
1324 * Kontextauswertung::
1325 * Eine Funktion auf alle Layout-Objekte anwenden::
1328 @node Kontextauswertung
1329 @subsection Kontextauswertung
1330 @translationof Context evaluation
1332 @cindex Aufrufen von Code während der Interpretation
1333 @cindex On-the-fly Code ausführen
1335 @funindex \applyContext
1337 Kontexte können während ihrer Interpretation mit Scheme-Code
1338 modifiziert werden. Die Syntax hierfür ist
1341 \applyContext @var{function}
1344 @var{function} sollte eine Scheme-Funktion sein, die ein
1345 einziges Argument braucht, welches der Kontext ist, auf den
1346 sie ausgeführt werden soll. Der folgende Code schreibt
1347 die aktuelle Taktzahlshould in die Standardausgabe
1348 während der Kompilation.
1353 (format #t "\nWe were called in barnumber ~a.\n"
1354 (ly:context-property x 'currentBarNumber)))
1359 @node Eine Funktion auf alle Layout-Objekte anwenden
1360 @subsection Eine Funktion auf alle Layout-Objekte anwenden
1361 @translationof Running a function on all layout objects
1364 @cindex Aufruf von Code für Layoutobjekte
1366 @funindex \applyOutput
1368 Der vielfältigste Weg, ein Objekt zu beeinflussen, ist
1369 @code{\applyOutput}. Die Syntax lautet:
1372 \applyOutput @var{Kontext} @var{proc}
1376 wobei @var{proc} eine Scheme-Funktion ist, die drei Argumente
1379 Während der Interpretation wird die Funktion @var{proc} für
1380 jedes Layoutobjekt aufgerufen, dass im Kontext @var{Kontext}
1381 vorgefunden wird, und zwar mit folgenden Argumenten:
1384 @item dem Layoutobjekt
1385 @item dem Kontext, in dem das Objekt erstellt wurde
1386 @item dem Kontext, in welchem @code{\applyOutput} bearbeitet wird.
1389 Zusätzlich findet sich der Grund für das Layoutobjekt, etwa
1390 der musikalische Ausdruck oder das Objekt, das für seine Erstellung
1391 verantwortlich war, in der Objekteigenschaft @code{cause}.
1392 Für einen Notenkopf beispielsweise ist das ein
1393 @rinternals{NoteHead}-Ereignis, und für einen Notenhals
1394 (ein @rinternals{Stem}-Objekt) ist es ein @rinternals{NoteHead}-Objekt.
1396 Hier ist eine Funktion, die mit @code{\applyOutput} benutzt
1397 werden kann; sie macht Notenköpfe auf der Mittellinie unsichtbar:
1399 @lilypond[quote,verbatim,ragged-right]
1400 #(define (blanker grob grob-origin context)
1401 (if (and (memq 'note-head-interface (ly:grob-interfaces grob))
1402 (eq? (ly:grob-property grob 'staff-position) 0))
1403 (set! (ly:grob-property grob 'transparent) #t)))
1406 e4 g8 \applyOutput #'Voice #blanker b d2
1411 @node Scheme-Vorgänge als Eigenschaften
1412 @section Scheme-Vorgänge als Eigenschaften
1413 @translationof Scheme procedures as properties
1415 Eigenschaften (wie Dicke, Richtung usw.) können mit
1416 @code{\override} auf feste Werte gesetzt werden, etwa:
1419 \override Stem #'thickness = #2.0
1422 Eigenschaften können auch auf eine Scheme-Prozedur gesetzt werden:
1424 @lilypond[fragment,verbatim,quote,relative=2]
1425 \override Stem #'thickness = #(lambda (grob)
1426 (if (= UP (ly:grob-property grob 'direction))
1433 In diesem Fall wird die Prozedur ausgeführt, sobal der Wert der
1434 Eigenschaft während das Formatierungsprozesses angefordert wird.
1436 Der größte Teil der Satzmaschinierie funtioniert mit derartigen
1437 Callbacks. Eigenschaften, die üblicherweise Callbacks
1438 benutzen, sind u. A.:
1442 Die Druckfunktion, die eine Ausgabe des Symbols ervorruft
1444 Die Funktion, die die horizontale Position setzt
1446 Die Funktion, die die Breite eines Objekts errechnet
1449 Die Funktionen brauchen immer ein einziges Argument, das der
1452 Wenn Funktionen mit mehreren Argumenten aufgerufen werden müssen,
1453 kann der aktuelle Grob mit einer Grob-Einschließung
1454 eingefügt werden. Hier eine Einstellung aus
1455 @code{AccidentalSuggestion}:
1459 ,(ly:make-simple-closure
1461 ,(ly:make-simple-closure
1462 (list ly:self-alignment-interface::centered-on-x-parent))
1463 ,(ly:make-simple-closure
1464 (list ly:self-alignment-interface::x-aligned-on-self)))))
1468 In diesem Beispiel werden sowohl @code{ly:self-alignment-interface::x-aligned-on-self}
1469 als auch @code{ly:self-alignment-interface::centered-on-x-parent}
1470 mit dem Grob als Argument aufgerufen. Die Resultate werden mit der
1471 @code{+}-Funktion addiert. Um sicherzugehen, dass die Addition
1472 richtig ausgeführt wird, wird das ganze Konstrukt in
1473 @code{ly:make-simple-closure} eingeschlossen.
1475 In der Tat ist die Benutzung einer einzelnen Funktion als
1476 Eigenschaftswert äquivalent zu
1479 (ly:make-simple-closure (ly:make-simple-closure (list @var{proc})))
1483 Das innere @code{ly:make-simple-closure} stellt den Grob als Argument
1484 für @var{proc} zur Verfügung, das äußere stellt sicher, dass das
1485 Resultat der Funktion ausgegeben wird und nicht das
1486 @code{simple-closure}-Objekt.
1489 @node Scheme-Code anstelle von \tweak verwenden
1490 @section Scheme-Code anstelle von @code{ weak} verwenden
1491 @translationof Using Scheme code instead of \tweak
1493 Der hauptsächliche Nachteil von @code{\tweak} ist seine
1494 syntaktische Inflexibilität. Folgender Code beispielsweise
1495 ergibt einen Syntaxfehler:
1498 F = \tweak #'font-size #-3 -\flageolet
1506 Anders gesagt verhält sich @code{\tweak} nicht wie eine Artikulation
1507 und kann auch nicht deren Syntax verwenden: man kann es nicht
1508 mit @code{^} oder @code{_} anfügen.
1510 Durch die Verwendung von Scheme kann dieses Problem umgangen werden.
1511 Der Weg zum Resultat wird gezeigt in
1512 @ref{Artikulationszeichen zu Noten hinzufügen (Beispiel)}, insbesondere
1513 wie @code{\displayMusic} benutzt wird, hilft hier weiter.
1516 F = #(let ((m (make-music 'ArticulationEvent
1517 'articulation-type "flageolet")))
1518 (set! (ly:music-property m 'tweaks)
1519 (acons 'font-size -3
1520 (ly:music-property m 'tweaks)))
1529 In diesem Beispiel werden die @code{tweaks}-Eigenschaften
1530 des Flageolet-Objekts @code{m} (mit @code{make-music} erstellt)
1531 werden mit @code{ly:music-property} ausgelesen, ein neues
1532 Schlüssel-Wert-Paar, um die Schriftgröße zu ändern, wird
1533 der Eigenschaftenliste mithilfe der @code{acons}-Schemefunktion
1534 vorangestellt, und das Resultat wird schließlich mit
1535 @code{set!} zurückgeschrieben. Das letzte Element des
1536 @code{let}-Blocks ist der Wiedergabewert, @code{m}.
1540 @node Schwierige Korrekturen
1541 @section Schwierige Korrekturen
1542 @translationof Difficult tweaks
1544 Hier finden sich einige Klassen an schwierigeren Anpassungen.
1549 Ein Typ der schwierigen Anpassungen ist die Erscheinung von
1550 Strecker-Objekten wie Binde- oder Legatobögen. Zunächst wird
1551 nur eins dieser Objekte erstellt, und sie können mit dem
1552 normalen Mechanismus verändert werden. In einigen Fällen
1553 reichen die Strecker jedoch über Zeilenumbrüche. Wenn das
1554 geschieht, werden diese Objekte geklont. Ein eigenes
1555 Objekt wird für jedes System erstellt, in dem es sich befindet.
1556 Sie sind Klone des originalen Objektes und erben alle
1557 Eigenschaften, auch @code{\override}-Befehle.
1559 Anders gesagt wirkt sich ein @code{\override} immer auf alle
1560 Stücke eines geteilten Streckers aus. Um nur einen Teil eines
1561 Streckers bei einem Zeilenumbruch zu verändern, ist es notwendig,
1562 in den Formatierungsprozess einzugreifen. Das Callback
1563 @code{after-line-breaking} enthält die Schemefunktion, die
1564 aufgerufen wird, nachdem Zeilenumbrüche errechnet worden sind
1565 und die Layout-Objekte über die unterschiedlichen Systeme verteilt
1568 Im folgenden Beispiel wird die Funktion
1569 @code{my-callback} definiert. Diese Funktion
1573 bestimmt, ob das Objekt durch Zeilenumbrüche geteilt ist,
1575 wenn ja, ruft sie alle geteilten Objekte auf,
1577 testet, ob es sich um das letzte der geteilten Objekte handelt,
1579 wenn ja, wird @code{extra-offset} gesetzt.
1582 Diese Funktion muss in @rinternals{Tie} (Bindebogen) installiert
1583 werden, und der letzte Teil eines gebrochenen Bindebogens wird
1584 nach oben verschoben.
1586 @lilypond[quote,verbatim,ragged-right]
1587 #(define (my-callback grob)
1589 ; have we been split?
1590 (orig (ly:grob-original grob))
1592 ; if yes, get the split pieces (our siblings)
1593 (siblings (if (ly:grob? orig)
1594 (ly:spanner-broken-into orig) '() )))
1596 (if (and (>= (length siblings) 2)
1597 (eq? (car (last-pair siblings)) grob))
1598 (ly:grob-set-property! grob 'extra-offset '(-2 . 5)))))
1601 \override Tie #'after-line-breaking =
1608 Wenn man diesen Trick anwendet, sollte das neue @code{after-line-breaking}
1609 auch das alte @code{after-line-breaking}-Callback aufrufen,
1610 wenn es vorhanden ist. Wenn diese Funktion etwa mit
1611 @code{Hairpin} (Crescendo-Klammer) eingesetzt wird, sollte auch
1612 @code{ly:hairpin::after-line-breaking} aufgerufen werden.
1616 Manche Objekte können aus technischen Gründen nicht mit @code{\override}
1617 verändert werden. Beispiele hiervon sind @code{NonMusicalPaperColumn}
1618 und @code{PaperColumn}. Sie können mit der
1619 @code{\overrideProperty}-Funktion geändert werden, die ähnlich wie
1620 @code{\once \override} funktioniert, aber eine andere Syntax einsetzt.
1624 #"Score.NonMusicalPaperColumn" % Grob-Bezeichnung
1625 #'line-break-system-details % Eigenschaftsbezeichnung
1626 #'((next-padding . 20)) % Wert
1629 Es sollte angemerkt werden, dass @code{\override}, wenn man es auf
1630 @code{NonMusicalPaperColumn} und @code{PaperColumn} anwendet, immernoch
1631 innerhalb der @code{\context}-Umgebung funktioniert.