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. See TRANSLATION for details.
12 @c Translators: Till Paala
14 @node Schnittstellen für Programmierer
15 @chapter Schnittstellen für Programmierer
16 @translationof Interfaces for programmers
18 Fortgeschrittene Anpassungen können mithilfe der Programmiersprache
19 Scheme vorgenommen werden. Wenn Sie Scheme nicht kennen, gibt
20 es eine grundlegende Einleitung in LilyPonds
21 @rlearning{Scheme-Übung}.
24 * Musikalische Funktionen::
25 * Schnittstelle für Programmierer::
26 * Komplizierte Funktionen erstellen::
27 * Programmierungsschnittstelle für Textbeschriftungen::
28 * Kontexte für Programmierer::
29 * Scheme-Vorgänge als Eigenschaften::
30 * Scheme-Code anstelle von \tweak verwenden::
31 * Schwierige Korrekturen::
35 @node Musikalische Funktionen
36 @section Musikalische Funktionen
37 @translationof Music functions
39 Dieser Abschnitt behandelt die Erstellung von musikalischen Funktionen
40 innerhalb von LilyPond.
43 * Überblick über musikalische Funktionen::
44 * Einfache Ersetzungsfunktionen::
45 * Paarige Ersetzungsfunktionen::
46 * Mathematik in Funktionen::
48 * Funktionen ohne Argumente::
49 * Überblick über vorhandene musikalische Funktionen::
52 @node Überblick über musikalische Funktionen
53 @subsection Überblick über musikalische Funktionen
54 @translationof Overview of music functions
56 Es ist einfach, eine Funktion zu erstellen, die Variablen
57 im LilyPond-Code ersetzt. Die allgemeine Form derartiger
62 #(define-music-function (parser location @var{var1} @var{var2}...@var{vari}... )
63 (@var{var1-type?} @var{var2-type?}...@var{vari-type?}...)
72 @multitable @columnfractions .33 .66
73 @item @var{vari} @tab die @var{i}te Variable
74 @item @var{vari-type?} @tab die Art der @var{i}ten Variable
75 @item @var{...Noten...} @tab normaler LilyPond-Code, in dem Variablen
76 wie @code{#$var1} usw. benutzt werden.
79 Die folgenden Eingabetypen können als Variablen in einer musikalischen
80 Funktion benutzt werden. Diese Liste ist nicht vollständig -- siehe
81 auch andere Dokumentationen überScheme für weitere Variablenarten.
83 @multitable @columnfractions .33 .66
84 @headitem Eingabetyp @tab @var{vari-type?}-Notation
85 @item Ganzzahl @tab @code{integer?}
86 @item Float (Dezimalzahl) @tab @code{number?}
87 @item Zeichenkette @tab @code{string?}
88 @item Textbeschriftung @tab @code{markup?}
89 @item Musikalischer Ausdruck @tab @code{ly:music?}
90 @item Ein Variablenpaar @tab @code{pair?}
93 Die Argumente @code{parser} und @code{location} sind zwingend erforderlich
94 und werden in einigen fortgeschrittenen Situationen eingesetzt. Das
95 Argument @code{parser} wird benutzt, um auf den Wert einer weiteren
96 LilyPond-Variable zuzugreifen. Das Argument @code{location} wird
97 benutzt, um den @qq{Ursprung} des musikalischen Ausdrucks zu definieren, der von
98 der musikalischen Funktion erzeugt wird. Das hilft, wenn ein
99 Syntaxfehler auftaucht: in solchen Fällen kann LilyPond mitteilen,
100 an welcher Stelle in der Eingabedatei sich der Fehler befindet.
103 @node Einfache Ersetzungsfunktionen
104 @subsection Einfache Ersetzungsfunktionen
105 @translationof Simple substitution functions
107 Hier ist ein einfaches Beispiel:
109 @lilypond[quote,verbatim,ragged-right]
110 padText = #(define-music-function (parser location padding) (number?)
112 \once \override TextScript #'padding = #$padding
120 c4^"piu mosso" fis a g
124 Musikalische Ausdrücke können auch ersetzt werden:
126 @lilypond[quote,verbatim,ragged-right]
127 custosNote = #(define-music-function (parser location note)
130 \once \override Voice.NoteHead #'stencil =
131 #ly:text-interface::print
132 \once \override Voice.NoteHead #'text =
133 \markup \musicglyph #"custodes.mensural.u0"
134 \once \override Voice.Stem #'stencil = ##f
138 { c' d' e' f' \custosNote g' }
141 Mehrere Variablen können benutzt werden:
143 @lilypond[quote,verbatim,ragged-right]
144 tempoPadded = #(define-music-function (parser location padding tempotext)
147 \once \override Score.MetronomeMark #'padding = $padding
148 \tempo \markup { \bold $tempotext }
152 \tempo \markup { "Low tempo" }
154 \tempoPadded #4.0 #"High tempo"
160 @node Paarige Ersetzungsfunktionen
161 @subsection Paarige Ersetzungsfunktionen
162 @translationof Paired substitution functions
164 Einige @code{\override}-Befehle benötigen ein Zahlenpaar
165 (als @code{cons}-Zelle in Scheme bezeichnet). Um beide Zahlen
166 einer Funktion zuzuweisen, kann entweder die Variable @code{pair?}
167 benutzt werden oder die @code{cons} in die musikalische Funktion
173 #(define-music-function (parser location beg-end)
176 \once \override Beam #'positions = #$beg-end
180 \manualBeam #'(3 . 6) c8 d e f
188 @lilypond[quote,verbatim,ragged-right]
190 #(define-music-function (parser location beg end)
193 \once \override Beam #'positions = #(cons $beg $end)
197 \manualBeam #3 #6 c8 d e f
202 @node Mathematik in Funktionen
203 @subsection Mathematik in Funktionen
204 @translationof Mathematics in functions
206 Musikalische Funktionen können neben einfachen Ersetzungen
207 auch Scheme-Programmcode enthalten:
209 @lilypond[quote,verbatim,ragged-right]
210 AltOn = #(define-music-function (parser location mag) (number?)
211 #{ \override Stem #'length = #$(* 7.0 mag)
212 \override NoteHead #'font-size =
213 #$(inexact->exact (* (/ 6.0 (log 2.0)) (log mag))) #})
216 \revert Stem #'length
217 \revert NoteHead #'font-size
220 { c'2 \AltOn #0.5 c'4 c'
221 \AltOn #1.5 c' c' \AltOff c'2 }
225 Dieses Beispiel kann auch umformuliert werden, um musikalische Ausdrücke
228 @lilypond[quote,verbatim,ragged-right]
229 withAlt = #(define-music-function (parser location mag music) (number? ly:music?)
230 #{ \override Stem #'length = #$(* 7.0 mag)
231 \override NoteHead #'font-size =
232 #$(inexact->exact (* (/ 6.0 (log 2.0)) (log mag)))
234 \revert Stem #'length
235 \revert NoteHead #'font-size #})
237 { c'2 \withAlt #0.5 {c'4 c'}
238 \withAlt #1.5 {c' c'} c'2 }
242 @node Leere Funktionen
243 @subsection Leere Funktionen
244 @translationof Void functions
246 Eine musikalische Funktion muss einen musikalischen Ausdruck
247 ausgeben, aber in manchen Fällen müssen Funktionen erstellt werden,
248 die keine Notation enthalten (wie etwa eine Funktion, mit der
249 man @qq{Point and Click} ausschalten kann). Um das vornehmen zu
250 können, wird ein @code{leere}r musikalischer Ausdruck ausgegeben.
252 Das ist der Grund, warum die Form, die ausgegeben wird,
253 @code{(make-music ...)} heißt. Wird die Eigenschaft
254 @code{'void} (engl. für @qq{leer}) auf @code{#t} gesetzt, wird der
255 Parser angewiesen, den ausgegebenen musikalischen Ausdruck zu ignorieren.
256 Der maßgebliche Teil der @code{'void}-Funktion ist also die Verarbeitung,
257 die die Funktion vornimmt, nicht der musikalische Ausdruck, der ausgegeben
262 #(define-music-function (parser location) ()
263 (ly:set-option 'point-and-click #f)
264 (make-music 'SequentialMusic 'void #t))
266 \noPointAndClick % disable point and click
270 @node Funktionen ohne Argumente
271 @subsection Funktionen ohne Argumente
272 @translationof Functions without arguments
274 In den meisten Fällen sollten Funktionen ohne Argumente mit einer
275 Variable notiert werden:
278 dolce = \markup@{ \italic \bold dolce @}
281 In einigen wenigen Fällen kann es aber auch sinnvoll sein, eine
282 musikalische Funktion ohne Argumente zu erstellen:
286 #(define-music-function (parser location) ()
287 (if (eq? #t (ly:get-option 'display-bar-numbers))
288 #@{ \once \override Score.BarNumber #'break-visibility = ##f #@}
292 Damit auch wirklich Taktzahlen angezeigt werden, wo die
293 Funktion eingesetzt wurde, muss @command{lilypond} mit
297 lilypond -d display-bar-numbers Dateiname.ly
304 @node Überblick über vorhandene musikalische Funktionen
305 @subsection Überblick über vorhandene musikalische Funktionen
306 @translationof Overview of available music functions
308 @c fixme ; this should be move somewhere else?
309 Die folgenden Befehle sind musikalische Funktionen:
311 @include identifiers.tely
315 @node Schnittstelle für Programmierer
316 @section Schnittstelle für Programmierer
317 @translationof Programmer interfaces
319 Dieser Abschnitt zeigt, wie LilyPond und
320 Scheme gemischt werden können.
323 * Eingabevariablen und Scheme::
324 * Interne Repräsentation der Musik::
328 @node Eingabevariablen und Scheme
329 @subsection Eingabevariablen und Scheme
330 @translationof Input variables and Scheme
332 Das Eingabeformat unterstützt die Notation von Variablen: im
333 folgenden Beispiel wird ein musikalischer Ausdruck einer Variable
334 mit der Bezeichnung @code{traLaLa} zugewiesen:
337 traLaLa = @{ c'4 d'4 @}
340 Der Geltungsbereich von Variablen ist beschränkt: im folgenden
341 Beispiel enthält die @code{\layout}-Umgebung auch eine
342 @code{traLaLa}-vVariable, die unabhängig von der äußeren
343 @code{\traLaLa}-Variable ist:
346 traLaLa = @{ c'4 d'4 @}
347 \layout @{ traLaLa = 1.0 @}
350 Grundsätzlich ist jede Eingabedatei ein Geltungsbereich, und
351 alle @code{\header}-, @code{\midi}- und @code{\layout}-Umgebungen
352 sind Geltungsbereiche, die unterhalb des globalen Geltungsbereiches
355 Sowohl Variablen als auch Geltungsbereiche sind in Form des
356 GUILE-Modulsystems implementiert. Ein anonymes Scheme-Modul
357 wird an jeden Geltunsbereich angehängt. Eine Zuweisung der form
360 traLaLa = @{ c'4 d'4 @}
364 wird intern in die Scheme-Definition
367 (define traLaLa @var{Scheme-Wert von `@code{... }'})
373 Das bedeutet, dass Eingabe- und Scheme-Variablen frei vermischt
374 werden können. Im nächsten Beispiel wird ein Notenfragment in
375 der Variable @code{traLaLa} gespeichert und mithilfe von Schme
376 dupliziert. Das Ergebnis wird in eine @code{\score}-Umgebung
377 mit der zweiten Variable @code{twice} integriert:
380 traLaLa = { c'4 d'4 }
382 %% dummy action to deal with parser lookahead
383 #(display "this needs to be here, sorry!")
385 #(define newLa (map ly:music-deep-copy
386 (list traLaLa traLaLa)))
388 (make-sequential-music newLa))
393 In diesem Beispiel geschieht die Zuweisung, nachdem der Parser
394 festgestellt hat, dass nichts interessantes mehr nach
395 @code{traLaLa = @{ ... @}} vorkommt. Ohne die Pseudovariable
396 in dem Beispiel würde die @code{newLa}-Devinition ausgeführt
397 werden, bevor @code{traLaLa} definiert ist, was zu einem
398 Syntax-Fehler führen würde.
400 Das obige Beispiel zeigt, wie man musikalische Ausdrücke
401 von der Eingabe in den Scheme-Interpretierer @qq{exportieren}
402 kann. Es geht auch in die andere Richtung. Indem man einen
403 Scheme-Wert in die Funktion @code{ly:export} einpackt, wird
404 der Scheme-Wert interpretiert als ob er in LilyPond-Syntax
405 notiert worden wäre. Anstatt @code{\twice} zu definieren,
406 hätte man also auch schreiben können:
410 @{ #(ly:export (make-sequential-music (list newLa))) @}
413 Scheme-Code wird sofort ausgewertet, wenn der Parser darauf
414 stößt. Um Scheme-Code in einem Makro zu definieren (das dann
415 erst später aufgerufen werden soll), müssen leere Funktionen
416 benutzt werden (siehe @ref{Leere Funktionen}) oder das Folgende:
420 (ly:set-option 'point-and-click #f))
429 Scheme- und LilyPond-Variablen können im LilyPond-Modus mit der
430 @code{--safe}-Option nicht vermischt werden.
433 @node Interne Repräsentation der Musik
434 @subsection Interne Repräsentation der Musik
435 @translationof Internal music representation
437 Wenn ein musikalischer Ausdruck ausgewertet wird, wird er in eine
438 Anzahl von musikalischen Scheme-Objekten konvertiert. Die Eigenschaft, die ein
439 musikalisches Objekt definiert, ist, dass es Zeit einnimmt. Zeit ist
440 eine rationale Zahl, die die Länge eines Stückes in ganzen Noten
443 Ein musikalisches Objekt hat drei Typusarten:
446 musikalische Bezeichnung: Jeder musikalische Ausdruck hat eine Bezeichnung.
447 Eine Note beispielsweise führt zu einem @rinternals{NoteEvent} und
448 @code{\simultaneous} führt zu @rinternals{SimultaneousMusic}. Eine Liste
449 aller möglichen Ausdrücke findet sich in der Referenz der Interna, unter
450 @rinternals{Music expressions}.
453 @q{Typ} oder Schnittstelle: Jede musikalische Bezeichnung hat mehrere
454 @qq{Typen} oder Schnittstellten, beispielsweise ist eine Note ein
455 @code{event}, ober sie ist auch ein @code{note-event}, ein
456 @code{rhythmic-event} und ein @code{melodic-event}. Alle diese
457 Notationsklassen finden sich in der Referenz der Interna unter
458 @rinternals{Music classes}.
461 C++-Objekt: Jedes musikalische Objekt wird von einem Objekt der
462 C++-Klasse @code{Music} repräsentiert.
465 Die eigentlich Information eines musikalischen Ausdrucks ist in
466 Eigenschaften gespeichert. Ein @rinternals{NoteEvent} hat zum
467 Beispiel @code{pitch}- und @code{duration}-Eigenschaften, die
468 die Tonhöhe und die Dauer dieser Note speichern. Eine Liste aller
469 verfügbaren Eigenschaften findet sich in der Referenz der Interna unter
470 @rinternals{Music properties}.
472 Ein zusammengesetzter musikalischer Ausdruck ist ein musikalisches
473 Objekt, das andere Objekte in seinen Eigenschaften enthält. Eine Liste
474 der Objekte kann in der @code{elements}-Eigenschaft eines
475 musikalischen Objektes gespeichert werden, oder ein einziges
476 @qq{Kind}-Objekt in der @code{element}-Eigenschaft. Sa hat etwa
477 @rinternals{SequentialMusic} seine @qq{Kinder} in @code{elements},
478 und @rinternals{GraceMusic} hat sein einziges Argument in
479 @code{element}. Der Hauptteil einer Wiederholung wird in der
480 @code{element}-Eigenschaft von @rinternals{RepeatedMusic} gespeichert,
481 und die Alternativen in @code{elements}.
485 @node Komplizierte Funktionen erstellen
486 @section Komplizierte Funktionen erstellen
487 @translationof Building complicated functions
489 Dieser Abschnitt zeigt, wie man Information zusammensucht,
490 um komplizierte musikalische Funktionen zu erstellen.
493 * Musikalische Funktionen darstellen::
494 * Eigenschaften von Musikobjekten::
495 * Verdoppelung einer Note mit Bindebögen (Beispiel)::
496 * Artikulationszeichen zu Noten hinzufügen (Beispiel)::
500 @node Musikalische Funktionen darstellen
501 @subsection Musikalische Funktionen darstellen
502 @translationof Displaying music expressions
504 @cindex interne Speicherung
505 @cindex Musikausdrücke anzeigen
506 @cindex Anzeigen von Musikausdrücken
508 @funindex displayMusic
509 @funindex \displayMusic
511 Wenn man eine musikalische Funktion erstellt, ist es oft
512 hilfreich sich anzuschauen, wie musikalische Funktionen
513 intern gespeichert werden. Das kann mit der Funktion
514 @code{\displayMusic} erreicht werden:
518 \displayMusic @{ c'4\f @}
535 (ly:make-duration 2 0 1 1)
537 (ly:make-pitch 0 0 0))
539 'AbsoluteDynamicEvent
544 Normalerweise gibt LilyPond diese Ausgabe auf der Konsole mit
545 allen anderen Nachrichten aus. Um die wichtigen Nachrichten
546 in einer Datei zu speichern, kann die Ausgabe in eine Datei
550 lilypond file.ly >display.txt
553 Mit etwas Umformatierung ist die gleiche Information sehr viel
557 (make-music 'SequentialMusic
558 'elements (list (make-music 'EventChord
559 'elements (list (make-music 'NoteEvent
560 'duration (ly:make-duration 2 0 1 1)
561 'pitch (ly:make-pitch 0 0 0))
562 (make-music 'AbsoluteDynamicEvent
566 Eine musikalische @code{@{ ... @}}-Sequenz hat die Bezeichnung
567 @code{SequentialMusic} und ihre inneren Ausdrücke werden als
568 Liste in seiner @code{'elements}-Eigenschaft gespeichert. Eine
569 Note ist als als ein @code{EventChord}-Ausdruck dargestellt,
570 der ein @code{NoteEvent}-Objekt (welches Dauer und
571 Tonhöhe speichert) und zusätzliche Information enthält (in
572 diesem Fall ein @code{AbsoluteDynamicEvent} mit einer
573 @code{"f"}-Text-Eigenschaft.
576 @node Eigenschaften von Musikobjekten
577 @subsection Eigenschaften von Musikobjekten
578 @translationof Music properties
580 Das @code{NoteEvent}-Objekt ist das erste Objekt der
581 @code{'elements}-Eigenschaft von @code{someNote}.
585 \displayMusic \someNote
593 (ly:make-duration 2 0 1 1)
595 (ly:make-pitch 0 0 0))))
598 Die @code{display-scheme-music}-Funktion ist die Funktion, die von
599 @code{\displayMusic} eingesetzt wird, um die Scheme-Repräsentation
600 eines musikalischen Ausdrucks anzuzeigen.
603 #(display-scheme-music (first (ly:music-property someNote 'elements)))
608 (ly:make-duration 2 0 1 1)
610 (ly:make-pitch 0 0 0))
613 Danach wird die Tonhöhe der Note von der @code{'pitch}-Eigenschaft
614 des @code{NoteEvent}-Objektes gelesen:
617 #(display-scheme-music
618 (ly:music-property (first (ly:music-property someNote 'elements))
621 (ly:make-pitch 0 0 0)
624 Die Tonhöhe einer Note kann geändert werden, indem man diese
625 @code{'pitch}-Eigenschaft umdefiniert:
627 @funindex \displayLilyMusic
628 @funindex displayLilyMusic
631 #(set! (ly:music-property (first (ly:music-property someNote 'elements))
633 (ly:make-pitch 0 1 0)) ;; Die Tonhöhen auf d' verändern.
634 \displayLilyMusic \someNote
640 @node Verdoppelung einer Note mit Bindebögen (Beispiel)
641 @subsection Verdoppelung einer Note mit Bindebögen (Beispiel)
642 @translationof Doubling a note with slurs (example)
644 In diesem Abschnitt soll gezeigt, werden, wie man eine
645 Funktion erstellt, die eine Eingabe wie @code{a}
646 nach @code{a( a)} umdefiniert. Dazu wird zuerst die
647 interne Repräsentation der Musik betrachtet, die
648 das Endergebnis darstellt:
651 \displayMusic@{ a'( a') @}
662 (ly:make-duration 2 0 1 1)
664 (ly:make-pitch 0 5 0))
675 (ly:make-duration 2 0 1 1)
677 (ly:make-pitch 0 5 0))
684 Eine schlechte Nachricht ist, dass die
685 @code{SlurEvent}-Ausdrücke @qq{innerhalb}
686 der Noten (bzw. innerhalb der
687 @code{EventChord}-Ausdrücke) hinzugefügt werden müssen.
689 Jetzt folgt eine Betrachtung der Eingabe:
701 (ly:make-duration 2 0 1 1)
703 (ly:make-pitch 0 5 0))))))
706 In der gewünschten Funktion muss also dieser Ausdruck
707 kopiert werden (sodass zwei Noten vorhanden sind, die
708 eine Sequenz bilden), dann müssen @code{SlurEvent}
709 zu der @code{'elements}-Eigenschaft jeder Noten hinzugefügt
710 werden, und schließlich muss eine @code{SequentialMusic}
711 mit den beiden @code{EventChords} erstellt werden.
714 doubleSlur = #(define-music-function (parser location note) (ly:music?)
715 "Return: @{ note ( note ) @}.
716 `note' is supposed to be an EventChord."
717 (let ((note2 (ly:music-deep-copy note)))
718 (set! (ly:music-property note 'elements)
719 (cons (make-music 'SlurEvent 'span-direction -1)
720 (ly:music-property note 'elements)))
721 (set! (ly:music-property note2 'elements)
722 (cons (make-music 'SlurEvent 'span-direction 1)
723 (ly:music-property note2 'elements)))
724 (make-music 'SequentialMusic 'elements (list note note2))))
728 @node Artikulationszeichen zu Noten hinzufügen (Beispiel)
729 @subsection Artikulationszeichen zu Noten hinzufügen (Beispiel)
730 @translationof Adding articulation to notes (example)
732 Am einfachsten können Artikulationszeichen zu Noten
733 hinzugefügt werden, indem man zwei musikalische Funktionen
734 in einen Kontext einfügt, wie erklärt in
735 @ref{Kontexte erstellen}. Hier soll jetzt eine musikalische
736 Funktion entwickelt werden, die das vornimmt.
738 Eine @code{$variable} innerhalb von @code{#@{...#@}} ist das
739 gleiche wie die normale Befehlsform @code{\variable} in
740 üblicher LilyPond-Notation. Es ist bekannt dass
747 in LilyPond nicht funktioniert. Das Problem könnte vermieden
748 werden, indem das Artikulationszeichen an eine Pseudonote
752 @{ << \music s1*0-.-> @}
756 aber in diesem Beispiel soll gezeigt werden, wie man das in
757 Scheme vornimmt. Zunächst wird die Eingabe und die gewünschte
770 (ly:make-duration 2 0 1 1)
772 (ly:make-pitch -1 0 0))))
783 (ly:make-duration 2 0 1 1)
785 (ly:make-pitch -1 0 0))
792 Dabei ist zu sehen, dass eine Note (@code{c4}) als @code{EventChord}
793 repräsentiert ist, mit einem @code{NoteEvent}-Ausdruck in ihrer
794 Elementenliste. Um eine Marcato-Artikulation hinzuzufügen, muss
795 ein @code{ArticulationEvent}-Ausdrcuk zu der Elementeigenschaft
796 des @code{EventChord}-Ausdrucks hinzugefügt werden.
798 Um diese Funktion zu bauen, wird folgerndermaßen begonnen:
801 (define (add-marcato event-chord)
802 "Add a marcato ArticulationEvent to the elements of `event-chord',
803 which is supposed to be an EventChord expression."
804 (let ((result-event-chord (ly:music-deep-copy event-chord)))
805 (set! (ly:music-property result-event-chord 'elements)
806 (cons (make-music 'ArticulationEvent
807 'articulation-type "marcato")
808 (ly:music-property result-event-chord 'elements)))
812 Die erste Zeile definiert eine Funktion in Scheme: Die Bezeichnung
813 der Funktion ist @code{add-marcato} und sie hat eine Variable
814 mit der Bezeichnung @code{event-chord}. In Scheme geht der Typ
815 einer Variable oft direkt aus der Bezeichnung hervor (das ist auch
816 eine gute Methode für andere Programmiersprachen).
823 ist eine (englische) Beschreibung, was diese Funktion tut. Sie ist
824 nicht unbedingt notwendig, aber genauso wie klare Variablen-Bezeichnungen
825 ist auch das eine gute Methode.
828 (let ((result-event-chord (ly:music-deep-copy event-chord)))
831 @code{let} wird benutzt, um die lokalen Variablen zu definieren. Hier
832 wird eine lokale Variable benutzt: @code{result-event-chord}. Sie erhält
833 den Wert @code{(ly:music-deep-copy event-chord)}. @code{ly:music-deep-copy}
834 ist eine LilyPond-spezifische Funktion, die wie alle Funktionen mit dem
835 Präfix @code{ly:} versehen ist. Sie wird benutzt, um eine Kopie eines
836 musikalischen Ausdrucks anzufertigen. Hier wird @code{event-chord}
837 (der Parameter der Funktion) kopiert. Die Funktion soll ja nur ein
838 Artikulationszeichen an einen @code{EventChord} gehängt werden, deshalb ist es besser,
839 den @code{EventChord}, der als Argument gegeben wurde, nicht zu
840 verändern, weil er woanders benutzt werden könnte.
842 Jetzt gibt es @code{result-event-chord}, wobei es sich um einen
843 @code{NoteEventChord}-Ausdruck handelt, welcher gleichzeigt eine Kopie
844 von @code{event-chord} ist. Das Makro wird seiner Eigenschaftsliste
848 (set! place new-value)
851 Was in diesem Fall @qq{gesetzt} werden soll (@qq{place}) ist die
852 @q{elements}-Eigenschaft des @code{result-event-chord}-Ausdrucks.
855 (ly:music-property result-event-chord 'elements)
858 @code{ly:music-property} ist die Funktion, mit der musikalische
859 Eigenschaften erreicht werden können (die @code{'elements},
860 @code{'duration}, @code{'pitch} usw., die in der Ausgabe von
861 @code{\displayMusic} weiter oben angezeigt werden). Der neue
862 Wert ist, was ehemals die Elemtneigenschaft war, mit einem
863 zusätzlichen Element: dem @code{ArticulationEvent}-Ausdruck,
864 der aus der Ausgabe von
865 @code{\displayMusic} kopiert werden kann:
868 (cons (make-music 'ArticulationEvent
869 'articulation-type "marcato")
870 (ly:music-property result-event-chord 'elements))
873 @code{cons} wird benutzt, um ein Element zu einer Liste hinzuzufügen,
874 ohne dass die originale Liste verändert wird. Das ist es, was die
875 Funktion tun soll: die gleiche Liste, aber mit dem neuen
876 @code{ArticulationEvent}-Ausdruck. Die Reihenfolge innerhalb
877 der Elementeeigenschaft ist hier nicht relevant.
879 Wenn schließlich die Marcato-Artikulation zu der entsprechenden
880 @code{elements}-Eigenschaft hinzuzugefügt ist, kann
881 @code{result-event-chord} ausgegeben werden, darum die letzte Zeile
884 Jetzt wird die @code{add-marcato}-Funktion in eine musikalische
885 Funktion umgewandelt:
888 addMarcato = #(define-music-function (parser location event-chord)
890 "Add a marcato ArticulationEvent to the elements of `event-chord',
891 which is supposed to be an EventChord expression."
892 (let ((result-event-chord (ly:music-deep-copy event-chord)))
893 (set! (ly:music-property result-event-chord 'elements)
894 (cons (make-music 'ArticulationEvent
895 'articulation-type "marcato")
896 (ly:music-property result-event-chord 'elements)))
900 Eine Überprüfung, dass die Funktion richtig arbeitet, geschieht
904 \displayMusic \addMarcato c4
908 @node Programmierungsschnittstelle für Textbeschriftungen
909 @section Programmierungsschnittstelle für Textbeschriftungen
910 @translationof Markup programmer interface
912 Textbeschriftungselemente sind als besondere Scheme-Funktionen
913 definiert, die ein Stencil-Objekt erstellen, dem eine Anzahl
914 an Argumenten übergeben wird.
917 * Beschriftungskonstruktionen in Scheme::
918 * Wie Beschriftungen intern funktionieren::
919 * Neue Definitionen von Beschriftungsbefehlen::
920 * Neue Definitionen von Beschriftungsbefehlen für Listen::
924 @node Beschriftungskonstruktionen in Scheme
925 @subsection Beschriftungskonstruktionen in Scheme
926 @translationof Markup construction in Scheme
928 @cindex Textbeschriftungsbefehle, definieren
929 @cindex Textbeschriftung, eigene Befehle
930 @cindex eigene Befehle, Textbeschriftung
931 @cindex markup, eigene Befehle
932 @cindex Befehle definieren, Textbeschriftung
934 Das @code{markup}-(Textbeschriftungs)Makro erstellt Textbeschriftungs-Ausdrücke
935 in Scheme, wobei eine LilyPond-artige Syntax benutzt wird. Beispielsweise
939 (markup #:column (#:line (#:bold #:italic "hello" #:raise 0.4 "world")
940 #:larger #:line ("foo" "bar" "baz")))
947 \markup \column @{ \line @{ \bold \italic "hello" \raise #0.4 "world" @}
948 \larger \line @{ foo bar baz @} @}
952 Dieses Beispiel zeigt die hauptsächlichen Übersetzungsregeln
953 zwischen normaler Textbeschriftungssyntax von LilyPond und der
954 Textbeschriftungssyntax in Scheme.
957 @multitable @columnfractions .3 .3
958 @item @b{LilyPond} @tab @b{Scheme}
959 @item @code{\markup Text1} @tab @code{(markup Text1)}
960 @item @code{\markup @{ Text1 Text2 ... @}} @tab
961 @code{(markup Text1 Text2 ... )}
962 @item @code{\Befehl} @tab @code{#:Befehl}
963 @item @code{\Variable} @tab @code{Variable}
964 @item @code{\center-column @{ ... @}} @tab @code{#:center-column ( ... )}
965 @item @code{Zeichenkette} @tab @code{"Zeichenkette"}
966 @item @code{#scheme-arg} @tab @code{scheme-arg}
970 Die gesamte Scheme-Sprache ist innerhalb des @code{markup}-Makros
971 zugänglich. Man kann also beispielsweise Funktionen innerhalb
972 eines @code{markup} aufrufen, um Zeichenketten zu manipulieren.
973 Das ist nützlich, wenn neue Beschriftungsbefehle definiert werden
975 @ref{Neue Definitionen von Beschriftungsbefehlen}).
980 Das Beschriftungslistenargument von Befehlen wie @code{#:line},
981 @code{#:center} und @code{#:column} kann keine Variable oder
982 das Resultat eines Funktionsaufrufen sein.
985 (markup #:line (Funktion-die-Textbeschriftung-ausgibt))
989 ist ungültig. Man sollte anstatt dessen die Funktionen
990 @code{make-line-markup}, @code{make-center-markup} oder
991 @code{make-column-markup} benutzen:
994 (markup (make-line-markup (Funktion-die-Textbeschriftung-ausgibt)))
998 @node Wie Beschriftungen intern funktionieren
999 @subsection Wie Beschriftungen intern funktionieren
1000 @translationof How markups work internally
1002 In einer Textbeschriftung wie
1005 \raise #0.5 "Textbeispiel"
1009 ist @code{\raise} unter der Haube durch die @code{raise-markup}-Funktion
1010 repräsentiert. Der Beschriftungsausdruck wird gespeichert als
1013 (list raise-markup 0.5 (list simple-markup "Textbeispiel"))
1016 Wenn die Beschriftung in druckbare Objekte (Stencils) umgewandelt ist,
1017 wir die @code{raise-markup}-Funktion folgendermaßen aufgerufen:
1021 @var{\layout object}
1022 @var{Liste der Eigenschafts-alists}
1024 @var{die "Textbeispiel"-Beschriftung})
1027 Die @code{raise-markup}-Funktion erstellt zunächt den Stencil für die
1028 @code{Textbeispiel}-Beschriftung und verschiebt dann diesen Stencil
1029 um 0.5 Notenlinienzwischenräume nach oben. Das ist ein einfaches
1030 Beispiel. Weitere, kompliziertere Beispiele finden sich nachfolgend
1031 in diesem Abschnitt und in der Datei
1032 @file{scm/@/define@/-markup@/-commands@/.scm}.
1035 @node Neue Definitionen von Beschriftungsbefehlen
1036 @subsection Neue Definitionen von Beschriftungsbefehlen
1037 @translationof New markup command definition
1039 Neue Textbeschriftungsbefehle können mit dem
1040 @code{define-markup-command}-Scheme-Makro definiert werden.
1043 (define-markup-command (@var{befehl-bezeichnung} @var{layout} @var{props} @var{arg1} @var{arg2} ...)
1044 (@var{arg1-type?} @var{arg2-type?} ...)
1052 @var{i}te Befehlsargument
1054 eine Eigenschaft für das @var{i}te Argument
1056 die @q{layout}-Definition
1058 eine Liste an alists, in der alle aktiven Eigenschaften enthalten sind
1061 Als einfaches Beispiel soll gezeigt werden, wie man einen
1062 @code{\smallcaps}-Befehl hinzufügen kann, der die Kapitälchen
1063 für die Schriftzeichen auswählt. Normalerweise würde man Kapitälchen
1064 folgendermaßen auswählen:
1067 \markup @{ \override #'(font-shape . caps) Text-in-Kapitälchen @}
1071 Damit wird die Kapitälchenschriftart ausgewählt, indem die
1072 @code{font-shape}-Eigesnchaft auf @code{#'caps} gesetzt wird,
1073 während @code{Text-in-caps} interpretiert wird.
1075 Damit diese Funkion als @code{\smallcaps}-Befehl zur Verfügung
1076 gestellt werden kann, muss eine Funktion mit @code{define-markup-command}
1077 definiert werden. Der Befehl braucht ein Argument vom Typ @code{markup}.
1078 Darum sollte der Beginn der Funktion lauten:
1081 (define-markup-command (smallcaps layout props argument) (markup?)
1086 Was jetzt folgt, ist der eigentliche Inhalt des Befehls: das
1087 @code{argument} soll als Beschriftung (markup) interpretiert werden,
1091 (interpret-markup layout @dots{} argument)
1095 Diese Interpretation sollte @code{'(font-shape . caps)} zu den
1096 aktiven Eigenschaften hinzufügen, weshalb wir das Folgende anstelle
1097 der @dots{} in dem Beispiel einfügen:
1100 (cons (list '(font-shape . caps) ) props)
1104 Die Variable @code{props} ist eine Liste an alists, und mit @code{cons}
1105 wird ihr eine zusätzliche Einstellung hinzugefügt.
1107 Man könnte sich auch vorstellen, dass ein Rezitativ einer Oper
1108 gesetzt werden soll, und ein Befehl wäre sehr bequem, mit dem
1109 man die Namen der Charaktere auf eine eigene Art darstellen könnte.
1110 Namen sollen in Kapitälchen gesetzt werden und etwas nach links und
1111 oben verschoben werden. Man kann also einen @code{\character}-Befehl
1112 definieren, der die nötige Verschiebung berücksichtigt und
1113 den neuen @code{\smallcaps}-Befehl einsetzt:
1116 #(define-markup-command (character layout props name) (string?)
1117 "Print the character name in small caps, translated to the left and
1118 top. Syntax: \\character #\"name\""
1119 (interpret-markup layout props
1120 (markup #:hspace 0 #:translate (cons -3 1) #:smallcaps name)))
1123 Hier ist eine Komplikation, die erklärt werden muss: Text über oder
1124 unter dem Notensystem wird vertikal verschoben um in einem bestimmten
1125 Abstand von dem System und den Noten zu sein (das wird als @qq{padding}
1126 bezeichnet). Um sicherzugehen, dass dieser Mechanismus nicht die
1127 vertikale Verschiebung von @code{#:translate} annulliert, wird
1128 die leere Zeichenkette (@code{#:hspace 0}) vor den zu verschiebenden
1129 Text gesetzt. Das @code{#:hspace 0} wird jetzt also über die Noten
1130 gesetzt und @code{name} dann relativ zu der leeren Zeichenkette
1131 verschoben. Im Endeffekt wird der Text nach links oben verschoben.
1133 Das Resultat sieht folgendermaßen aus:
1137 c''^\markup \character #"Cleopatra"
1138 e'^\markup \character #"Giulio Cesare"
1142 @lilypond[quote,ragged-right]
1143 #(define-markup-command (smallcaps layout props str) (string?)
1144 "Print the string argument in small caps. Syntax: \\smallcaps #\"string\""
1145 (interpret-markup layout props
1148 (if (= (string-length s) 0)
1150 (markup #:large (string-upcase (substring s 0 1))
1151 #:translate (cons -0.6 0)
1152 #:tiny (string-upcase (substring s 1)))))
1153 (string-split str #\Space)))))
1155 #(define-markup-command (character layout props name) (string?)
1156 "Print the character name in small caps, translated to the left and
1157 top. Syntax: \\character #\"name\""
1158 (interpret-markup layout props
1159 (markup #:hspace 0 #:translate (cons -3 1) #:smallcaps name)))
1162 c''^\markup \character #"Cleopatra" c'' c'' c''
1163 e'^\markup \character #"Giulio Cesare" e' e' e'
1167 In diesen Befehlen wurden Kapitälchen eingesetzt, aber es kann
1168 vorkommen, dass die Schriftart keine Kapitälchen zur Verfügung
1169 stellt. In diesem Fall können die Kapitälchen nachempfunden
1170 werden, indem man Großbuchstaben setzt, deren Anfangsbuchstabe
1171 etwas größer gesetzt wird:
1174 #(define-markup-command (smallcaps layout props str) (string?)
1175 "Print the string argument in small caps."
1176 (interpret-markup layout props
1179 (if (= (string-length s) 0)
1181 (markup #:large (string-upcase (substring s 0 1))
1182 #:translate (cons -0.6 0)
1183 #:tiny (string-upcase (substring s 1)))))
1184 (string-split str #\Space)))))
1187 Der @code{smallcaps}-Befehl spaltet die Argumente zuerst in
1188 Einzelstücke auf, die von Leerzeichen getrennt sind
1189 (@code{(string-split str #\Space)}); für jedes Einzelstück
1190 wird dann eine Beschriftung aufgebaut, deren erster Buchstabe
1191 vergrößert wird und als Versalbuchstabe gesetzt wird
1192 (@code{#:large (string-upcase (substring s 0 1))}), und eine
1193 zweite Versalbuchstaben gesetzt werden
1194 (@code{#:tiny (string-upcase (substring s 1))}). Wenn
1195 LilyPond ein Leerzeichen zwischen Beschriftungen einer Zeile
1196 entdeckt, wird die zweite Beschriftung nach links verschoben
1197 (@code{#:translate (cons -0.6 0) ...}). Dann werden die
1198 Beschriftungen für jedes Einzelstück in eine Zeile gesetzt
1199 @code{(make-line-markup ...)}. Schließlich wird die resultierende
1200 Beschriftung an die @code{interpret-markup}-Funktion zusammen
1201 mit den Argumenten @code{layout} und @code{props} weitergereicht.
1203 Achtung: ist gibt keinen internen Befehl @code{\smallCaps}, der
1204 benutzt werden kann, um Text in Kapitälchen zu setzen. Siehe auch
1205 @ref{Text markup commands}.
1209 Im Moment sind die möglichen Kombinationen von Argumenten (nach den
1210 Standardargumenten @var{layout} und @var{props}), die mit
1211 @code{define-markup-command} definiert werden, wie folgt
1215 @item (kein Argument)
1218 @itemx @var{markup markup}
1220 @itemx @var{scm markup}
1221 @itemx @var{scm scm}
1222 @itemx @var{scm scm markup}
1223 @itemx @var{scm scm markup markup}
1224 @itemx @var{scm markup markup}
1225 @itemx @var{scm scm scm}
1229 Hier stellt @var{scm} native Scheme-Datentypen dar wie
1230 @q{number} oder @q{string}.
1232 Es ist beispielsweise nicht möglich, einen Beschriftungsbefehl
1233 @code{foo} mit vier Argumenten in folgender Weise zu nutzen:
1236 #(define-markup-command (foo layout props
1237 num1 str1 num2 str2)
1238 (number? string? number? string?)
1243 Wenn es folgendermaßen eingesetzt wird:
1246 \markup \foo #1 #"bar" #2 #"baz"
1249 @cindex Scheme signature
1250 @cindex Signatur, Scheme
1252 beschwert sich @command{lilypond}, dass @code{foo} wegen einer ungekannten
1253 Scheme Signatur nicht analysiert werden kann.
1256 @node Neue Definitionen von Beschriftungsbefehlen für Listen
1257 @subsection Neue Definitionen von Beschriftungsbefehlen für Listen
1258 @translationof New markup list command definition
1260 Beschriftungslistenbefehle können mit dem Scheme-Makro
1261 @code{define-markup-list-command} definiert werden, welches
1262 sich ähnlich verhält wie das
1263 @code{define-markup-command}-Makro, das schon beschrieben
1264 wurde in @ref{Neue Definitionen von Beschriftungsbefehlen}. Ein Unterschied
1265 ist, dass bei diesem Listen-Makro eine ganze Liste an
1266 Stecils ausgegeben wird.
1268 Im folgenden Beispiel wird ein @code{\paragraph}-Beschriftungslistenbefehl
1269 definiert, welcher eine Liste von Zeilen im Blocksatz ausgibt, von
1270 denen die erste Zeile eingerückt ist. Der Einzug wird aus dem
1271 @code{props}-Argument entnommen.
1274 #(define-markup-list-command (paragraph layout props args) (markup-list?)
1275 (let ((indent (chain-assoc-get 'par-indent props 2)))
1276 (interpret-markup-list layout props
1277 (make-justified-lines-markup-list (cons (make-hspace-markup indent)
1281 Neben den üblichen @code{layout} und @code{props}-Argumenten, nimmt der
1282 @code{paragraph}-Beschriftungslistenbefehl als Argument eine Beschriftungsliste,
1283 die @code{args} genannt wird. Das Prädikat für Beschriftungslisten ist
1284 @code{markup-list?}.
1286 Zuerst errechnet die Funktion die Breite des Einzugs, eine Eigenschaft
1287 mit der Bezeichnung @code{par-indent} anhand der Eigenschaftsliste
1288 @code{props}. Wenn die Eigenschaft nicht gefunden wird, ist der
1289 Standardwert @code{2}. Danach wird eine Liste von Zeilen im Blocksatz
1290 erstellt, wobei die @code{make-justified-lines-markup-list}-Funktion
1291 eingesetzt wird, die verwandt ist mit dem eingebauten
1292 @code{\justified-lines}-Beschriftungslistenbefehl. Horizontaler
1293 Platz wird zu Beginn eingefügt mit der @code{make-hspace-markup}-Funktion.
1294 Zuletzt wird die Beschriftungsliste ausgewertet durch die
1295 @code{interpret-markup-list}-Funktion.
1297 Dieser neue Beschriftungslistenbefehl kann wie folgt benutzt werden:
1302 Die Kunst des Notensatzes wird auch als \italic @{Notenstich@} bezeichnet. Dieser
1303 Begriff stammt aus dem traditionellen Notendruck. Noch bis vor etwa
1304 20 Jahren wurden Noten erstellt, indem man sie in eine Zink- oder
1305 Zinnplatte schnitt oder mit Stempeln schlug.
1307 \override-lines #'(par-indent . 4) \paragraph @{
1308 Diese Platte wurde dann mit Druckerschwärze versehen, so dass sie
1309 in den geschnittenen und gestempelten Vertiefungen blieb. Diese
1310 Vertiefungen schwärzten dann ein auf die Platte gelegtes Papier.
1311 Das Gravieren wurde vollständig von Hand erledigt.
1318 @node Kontexte für Programmierer
1319 @section Kontexte für Programmierer
1320 @translationof Contexts for programmers
1323 * Kontextauswertung::
1324 * Eine Funktion auf alle Layout-Objekte anwenden::
1327 @node Kontextauswertung
1328 @subsection Kontextauswertung
1329 @translationof Context evaluation
1331 @cindex Aufrufen von Code während der Interpretation
1332 @cindex On-the-fly Code ausführen
1334 @funindex \applyContext
1336 Kontexte können während ihrer Interpretation mit Scheme-Code
1337 modifiziert werden. Die Syntax hierfür ist
1340 \applyContext @var{function}
1343 @var{function} sollte eine Scheme-Funktion sein, die ein
1344 einziges Argument braucht, welches der Kontext ist, auf den
1345 sie ausgeführt werden soll. Der folgende Code schreibt
1346 die aktuelle Taktzahlshould in die Standardausgabe
1347 während der Kompilation.
1352 (format #t "\nWe were called in barnumber ~a.\n"
1353 (ly:context-property x 'currentBarNumber)))
1358 @node Eine Funktion auf alle Layout-Objekte anwenden
1359 @subsection Eine Funktion auf alle Layout-Objekte anwenden
1360 @translationof Running a function on all layout objects
1363 @cindex Aufruf von Code für Layoutobjekte
1365 @funindex \applyOutput
1367 Der vielfältigste Weg, ein Objekt zu beeinflussen, ist
1368 @code{\applyOutput}. Die Syntax lautet:
1371 \applyOutput @var{Kontext} @var{proc}
1375 wobei @var{proc} eine Scheme-Funktion ist, die drei Argumente
1378 Während der Interpretation wird die Funktion @var{proc} für
1379 jedes Layoutobjekt aufgerufen, dass im Kontext @var{Kontext}
1380 vorgefunden wird, und zwar mit folgenden Argumenten:
1383 @item dem Layoutobjekt
1384 @item dem Kontext, in dem das Objekt erstellt wurde
1385 @item dem Kontext, in welchem @code{\applyOutput} bearbeitet wird.
1388 Zusätzlich findet sich der Grund für das Layoutobjekt, etwa
1389 der musikalische Ausdruck oder das Objekt, das für seine Erstellung
1390 verantwortlich war, in der Objekteigenschaft @code{cause}.
1391 Für einen Notenkopf beispielsweise ist das ein
1392 @rinternals{NoteHead}-Ereignis, und für einen Notenhals
1393 (ein @rinternals{Stem}-Objekt) ist es ein @rinternals{NoteHead}-Objekt.
1395 Hier ist eine Funktion, die mit @code{\applyOutput} benutzt
1396 werden kann; sie macht Notenköpfe auf der Mittellinie unsichtbar:
1398 @lilypond[quote,verbatim,ragged-right]
1399 #(define (blanker grob grob-origin context)
1400 (if (and (memq 'note-head-interface (ly:grob-interfaces grob))
1401 (eq? (ly:grob-property grob 'staff-position) 0))
1402 (set! (ly:grob-property grob 'transparent) #t)))
1405 e4 g8 \applyOutput #'Voice #blanker b d2
1410 @node Scheme-Vorgänge als Eigenschaften
1411 @section Scheme-Vorgänge als Eigenschaften
1412 @translationof Scheme procedures as properties
1414 Eigenschaften (wie Dicke, Richtung usw.) können mit
1415 @code{\override} auf feste Werte gesetzt werden, etwa:
1418 \override Stem #'thickness = #2.0
1421 Eigenschaften können auch auf eine Scheme-Prozedur gesetzt werden:
1423 @lilypond[fragment,verbatim,quote,relative=2]
1424 \override Stem #'thickness = #(lambda (grob)
1425 (if (= UP (ly:grob-property grob 'direction))
1432 In diesem Fall wird die Prozedur ausgeführt, sobal der Wert der
1433 Eigenschaft während das Formatierungsprozesses angefordert wird.
1435 Der größte Teil der Satzmaschinierie funtioniert mit derartigen
1436 Callbacks. Eigenschaften, die üblicherweise Callbacks
1437 benutzen, sind u. A.:
1441 Die Druckfunktion, die eine Ausgabe des Symbols ervorruft
1443 Die Funktion, die die horizontale Position setzt
1445 Die Funktion, die die Breite eines Objekts errechnet
1448 Die Funktionen brauchen immer ein einziges Argument, das der
1451 Wenn Funktionen mit mehreren Argumenten aufgerufen werden müssen,
1452 kann der aktuelle Grob mit einer Grob-Einschließung
1453 eingefügt werden. Hier eine Einstellung aus
1454 @code{AccidentalSuggestion}:
1458 ,(ly:make-simple-closure
1460 ,(ly:make-simple-closure
1461 (list ly:self-alignment-interface::centered-on-x-parent))
1462 ,(ly:make-simple-closure
1463 (list ly:self-alignment-interface::x-aligned-on-self)))))
1467 In diesem Beispiel werden sowohl @code{ly:self-alignment-interface::x-aligned-on-self}
1468 als auch @code{ly:self-alignment-interface::centered-on-x-parent}
1469 mit dem Grob als Argument aufgerufen. Die Resultate werden mit der
1470 @code{+}-Funktion addiert. Um sicherzugehen, dass die Addition
1471 richtig ausgeführt wird, wird das ganze Konstrukt in
1472 @code{ly:make-simple-closure} eingeschlossen.
1474 In der Tat ist die Benutzung einer einzelnen Funktion als
1475 Eigenschaftswert äquivalent zu
1478 (ly:make-simple-closure (ly:make-simple-closure (list @var{proc})))
1482 Das innere @code{ly:make-simple-closure} stellt den Grob als Argument
1483 für @var{proc} zur Verfügung, das äußere stellt sicher, dass das
1484 Resultat der Funktion ausgegeben wird und nicht das
1485 @code{simple-closure}-Objekt.
1488 @node Scheme-Code anstelle von \tweak verwenden
1489 @section Scheme-Code anstelle von @code{ weak} verwenden
1490 @translationof Using Scheme code instead of \tweak
1492 Der hauptsächliche Nachteil von @code{\tweak} ist seine
1493 syntaktische Inflexibilität. Folgender Code beispielsweise
1494 ergibt einen Syntaxfehler:
1497 F = \tweak #'font-size #-3 -\flageolet
1505 Anders gesagt verhält sich @code{\tweak} nicht wie eine Artikulation
1506 und kann auch nicht deren Syntax verwenden: man kann es nicht
1507 mit @code{^} oder @code{_} anfügen.
1509 Durch die Verwendung von Scheme kann dieses Problem umgangen werden.
1510 Der Weg zum Resultat wird gezeigt in
1511 @ref{Artikulationszeichen zu Noten hinzufügen (Beispiel)}, insbesondere
1512 wie @code{\displayMusic} benutzt wird, hilft hier weiter.
1515 F = #(let ((m (make-music 'ArticulationEvent
1516 'articulation-type "flageolet")))
1517 (set! (ly:music-property m 'tweaks)
1518 (acons 'font-size -3
1519 (ly:music-property m 'tweaks)))
1528 In diesem Beispiel werden die @code{tweaks}-Eigenschaften
1529 des Flageolet-Objekts @code{m} (mit @code{make-music} erstellt)
1530 werden mit @code{ly:music-property} ausgelesen, ein neues
1531 Schlüssel-Wert-Paar, um die Schriftgröße zu ändern, wird
1532 der Eigenschaftenliste mithilfe der @code{acons}-Schemefunktion
1533 vorangestellt, und das Resultat wird schließlich mit
1534 @code{set!} zurückgeschrieben. Das letzte Element des
1535 @code{let}-Blocks ist der Wiedergabewert, @code{m}.
1539 @node Schwierige Korrekturen
1540 @section Schwierige Korrekturen
1541 @translationof Difficult tweaks
1543 Hier finden sich einige Klassen an schwierigeren Anpassungen.
1548 Ein Typ der schwierigen Anpassungen ist die Erscheinung von
1549 Strecker-Objekten wie Binde- oder Legatobögen. Zunächst wird
1550 nur eins dieser Objekte erstellt, und sie können mit dem
1551 normalen Mechanismus verändert werden. In einigen Fällen
1552 reichen die Strecker jedoch über Zeilenumbrüche. Wenn das
1553 geschieht, werden diese Objekte geklont. Ein eigenes
1554 Objekt wird für jedes System erstellt, in dem es sich befindet.
1555 Sie sind Klone des originalen Objektes und erben alle
1556 Eigenschaften, auch @code{\override}-Befehle.
1558 Anders gesagt wirkt sich ein @code{\override} immer auf alle
1559 Stücke eines geteilten Streckers aus. Um nur einen Teil eines
1560 Streckers bei einem Zeilenumbruch zu verändern, ist es notwendig,
1561 in den Formatierungsprozess einzugreifen. Das Callback
1562 @code{after-line-breaking} enthält die Schemefunktion, die
1563 aufgerufen wird, nachdem Zeilenumbrüche errechnet worden sind
1564 und die Layout-Objekte über die unterschiedlichen Systeme verteilt
1567 Im folgenden Beispiel wird die Funktion
1568 @code{my-callback} definiert. Diese Funktion
1572 bestimmt, ob das Objekt durch Zeilenumbrüche geteilt ist,
1574 wenn ja, ruft sie alle geteilten Objekte auf,
1576 testet, ob es sich um das letzte der geteilten Objekte handelt,
1578 wenn ja, wird @code{extra-offset} gesetzt.
1581 Diese Funktion muss in @rinternals{Tie} (Bindebogen) installiert
1582 werden, und der letzte Teil eines gebrochenen Bindebogens wird
1583 nach oben verschoben.
1585 @lilypond[quote,verbatim,ragged-right]
1586 #(define (my-callback grob)
1588 ; have we been split?
1589 (orig (ly:grob-original grob))
1591 ; if yes, get the split pieces (our siblings)
1592 (siblings (if (ly:grob? orig)
1593 (ly:spanner-broken-into orig) '() )))
1595 (if (and (>= (length siblings) 2)
1596 (eq? (car (last-pair siblings)) grob))
1597 (ly:grob-set-property! grob 'extra-offset '(-2 . 5)))))
1600 \override Tie #'after-line-breaking =
1607 Wenn man diesen Trick anwendet, sollte das neue @code{after-line-breaking}
1608 auch das alte @code{after-line-breaking}-Callback aufrufen,
1609 wenn es vorhanden ist. Wenn diese Funktion etwa mit
1610 @code{Hairpin} (Crescendo-Klammer) eingesetzt wird, sollte auch
1611 @code{ly:hairpin::after-line-breaking} aufgerufen werden.
1615 Manche Objekte können aus technischen Gründen nicht mit @code{\override}
1616 verändert werden. Beispiele hiervon sind @code{NonMusicalPaperColumn}
1617 und @code{PaperColumn}. Sie können mit der
1618 @code{\overrideProperty}-Funktion geändert werden, die ähnlich wie
1619 @code{\once \override} funktioniert, aber eine andere Syntax einsetzt.
1623 #"Score.NonMusicalPaperColumn" % Grob-Bezeichnung
1624 #'line-break-system-details % Eigenschaftsbezeichnung
1625 #'((next-padding . 20)) % Wert
1628 Es sollte angemerkt werden, dass @code{\override}, wenn man es auf
1629 @code{NonMusicalPaperColumn} und @code{PaperColumn} anwendet, immernoch
1630 innerhalb der @code{\context}-Umgebung funktioniert.