@c -*- coding: utf-8; mode: texinfo; -*-
@ignore
- Translation of GIT committish: d96023d8792c8af202c7cb8508010c0d3648899d
+ Translation of GIT committish: 7b70644b95f383b4281e9ffa146d315d2ada11d3
When revising a translation, copy the HEAD committish of the
version that you are working on. See TRANSLATION for details.
@c \version "2.12.0"
-@node Interfaces for programmers
-@chapter Interfaces for programmers
+@c Translators: Till Paala
+
+@node Schnittstellen für Programmierer
+@chapter Schnittstellen für Programmierer
+@translationof Interfaces for programmers
Fortgeschrittene Anpassungen können mithilfe der Programmiersprache
Scheme vorgenommen werden. Wenn Sie Scheme nicht kennen, gibt
es eine grundlegende Einleitung in LilyPonds
-@rlearning{Scheme tutorial}.
+@rlearning{Scheme-Übung}.
@menu
-* Music functions::
-* Programmer interfaces::
-* Building complicated functions::
-* Markup programmer interface::
-* Contexts for programmers::
-* Scheme procedures as properties::
-* Using Scheme code instead of \tweak::
-* Difficult tweaks::
+* Musikalische Funktionen::
+* Schnittstelle für Programmierer::
+* Komplizierte Funktionen erstellen::
+* Programmierungsschnittstelle für Textbeschriftungen::
+* Kontexte für Programmierer::
+* Scheme-Vorgänge als Eigenschaften::
+* Scheme-Code anstelle von \tweak verwenden::
+* Schwierige Korrekturen::
@end menu
-@node Music functions
-@section Music functions
+@node Musikalische Funktionen
+@section Musikalische Funktionen
+@translationof Music functions
Dieser Abschnitt behandelt die Erstellung von musikalischen Funktionen
innerhalb von LilyPond.
@menu
-* Overview of music functions::
-* Simple substitution functions::
-* Paired substitution functions::
-* Mathematics in functions::
-* Void functions::
-* Functions without arguments::
-* Overview of available music functions::
+* Überblick über musikalische Funktionen::
+* Einfache Ersetzungsfunktionen::
+* Paarige Ersetzungsfunktionen::
+* Mathematik in Funktionen::
+* Leere Funktionen::
+* Funktionen ohne Argumente::
+* Überblick über vorhandene musikalische Funktionen::
@end menu
-@node Overview of music functions
-@subsection Overview of music functions
+@node Überblick über musikalische Funktionen
+@subsection Überblick über musikalische Funktionen
+@translationof Overview of music functions
Es ist einfach, eine Funktion zu erstellen, die Variablen
im LilyPond-Code ersetzt. Die allgemeine Form derartiger
an welcher Stelle in der Eingabedatei sich der Fehler befindet.
-@node Simple substitution functions
-@subsection Simple substitution functions
+@node Einfache Ersetzungsfunktionen
+@subsection Einfache Ersetzungsfunktionen
+@translationof Simple substitution functions
Hier ist ein einfaches Beispiel:
@end lilypond
-@node Paired substitution functions
-@subsection Paired substitution functions
+@node Paarige Ersetzungsfunktionen
+@subsection Paarige Ersetzungsfunktionen
+@translationof Paired substitution functions
Einige @code{\override}-Befehle benötigen ein Zahlenpaar
(als @code{cons}-Zelle in Scheme bezeichnet). Um beide Zahlen
@end lilypond
-@node Mathematics in functions
-@subsection Mathematics in functions
+@node Mathematik in Funktionen
+@subsection Mathematik in Funktionen
+@translationof Mathematics in functions
Musikalische Funktionen können neben einfachen Ersetzungen
auch Scheme-Programmcode enthalten:
@end lilypond
-@node Void functions
-@subsection Void functions
+@node Leere Funktionen
+@subsection Leere Funktionen
+@translationof Void functions
Eine musikalische Funktion muss einen musikalischen Ausdruck
ausgeben, aber in manchen Fällen müssen Funktionen erstellt werden,
@end example
-@node Functions without arguments
-@subsection Functions without arguments
+@node Funktionen ohne Argumente
+@subsection Funktionen ohne Argumente
+@translationof Functions without arguments
In den meisten Fällen sollten Funktionen ohne Argumente mit einer
Variable notiert werden:
aufgerufen werden.
-@node Overview of available music functions
-@subsection Overview of available music functions
+@node Überblick über vorhandene musikalische Funktionen
+@subsection Überblick über vorhandene musikalische Funktionen
+@translationof Overview of available music functions
@c fixme ; this should be move somewhere else?
Die folgenden Befehle sind musikalische Funktionen:
-@node Programmer interfaces
-@section Programmer interfaces
+@node Schnittstelle für Programmierer
+@section Schnittstelle für Programmierer
+@translationof Programmer interfaces
Dieser Abschnitt zeigt, wie LilyPond und
Scheme gemischt werden können.
@menu
-* Input variables and Scheme::
-* Internal music representation::
+* Eingabevariablen und Scheme::
+* Interne Repräsentation der Musik::
@end menu
-@node Input variables and Scheme
-@subsection Input variables and Scheme
+@node Eingabevariablen und Scheme
+@subsection Eingabevariablen und Scheme
+@translationof Input variables and Scheme
Das Eingabeformat unterstützt die Notation von Variablen: im
folgenden Beispiel wird ein musikalischer Ausdruck einer Variable
Scheme-Code wird sofort ausgewertet, wenn der Parser darauf
stößt. Um Scheme-Code in einem Makro zu definieren (das dann
erst später aufgerufen werden soll), müssen leere Funktionen
-benutzt werden (siehe @ref{Void functions}) oder das Folgende:
+benutzt werden (siehe @ref{Leere Funktionen}) oder das Folgende:
@example
#(define (nopc)
@code{--safe}-Option nicht vermischt werden.
-@node Internal music representation
-@subsection Internal music representation
+@node Interne Repräsentation der Musik
+@subsection Interne Repräsentation der Musik
+@translationof Internal music representation
Wenn ein musikalischer Ausdruck ausgewertet wird, wird er in eine
Anzahl von musikalischen Scheme-Objekten konvertiert. Die Eigenschaft, die ein
-@node Building complicated functions
-@section Building complicated functions
+@node Komplizierte Funktionen erstellen
+@section Komplizierte Funktionen erstellen
+@translationof Building complicated functions
Dieser Abschnitt zeigt, wie man Information zusammensucht,
um komplizierte musikalische Funktionen zu erstellen.
@menu
-* Displaying music expressions::
-* Music properties::
-* Doubling a note with slurs (example)::
-* Adding articulation to notes (example)::
+* Musikalische Funktionen darstellen::
+* Eigenschaften von Musikobjekten::
+* Verdoppelung einer Note mit Bindebögen (Beispiel)::
+* Artikulationszeichen zu Noten hinzufügen (Beispiel)::
@end menu
-@node Displaying music expressions
-@subsection Displaying music expressions
+@node Musikalische Funktionen darstellen
+@subsection Musikalische Funktionen darstellen
+@translationof Displaying music expressions
@cindex interne Speicherung
@cindex Musikausdrücke anzeigen
@code{"f"}-Text-Eigenschaft.
-@node Music properties
-@subsection Music properties
+@node Eigenschaften von Musikobjekten
+@subsection Eigenschaften von Musikobjekten
+@translationof Music properties
Das @code{NoteEvent}-Objekt ist das erste Objekt der
@code{'elements}-Eigenschaft von @code{someNote}.
@end example
-@node Doubling a note with slurs (example)
-@subsection Doubling a note with slurs (example)
+@node Verdoppelung einer Note mit Bindebögen (Beispiel)
+@subsection Verdoppelung einer Note mit Bindebögen (Beispiel)
+@translationof Doubling a note with slurs (example)
In diesem Abschnitt soll gezeigt, werden, wie man eine
Funktion erstellt, die eine Eingabe wie @code{a}
@end example
-@node Adding articulation to notes (example)
-@subsection Adding articulation to notes (example)
+@node Artikulationszeichen zu Noten hinzufügen (Beispiel)
+@subsection Artikulationszeichen zu Noten hinzufügen (Beispiel)
+@translationof Adding articulation to notes (example)
Am einfachsten können Artikulationszeichen zu Noten
hinzugefügt werden, indem man zwei musikalische Funktionen
in einen Kontext einfügt, wie erklärt in
-@ref{Creating contexts}. Hier soll jetzt eine musikalische
+@ref{Kontexte erstellen}. Hier soll jetzt eine musikalische
Funktion entwickelt werden, die das vornimmt.
Eine @code{$variable} innerhalb von @code{#@{...#@}} ist das
@end example
-@node Markup programmer interface
-@section Markup programmer interface
+@node Programmierungsschnittstelle für Textbeschriftungen
+@section Programmierungsschnittstelle für Textbeschriftungen
+@translationof Markup programmer interface
Textbeschriftungselemente sind als besondere Scheme-Funktionen
definiert, die ein Stencil-Objekt erstellen, dem eine Anzahl
an Argumenten übergeben wird.
@menu
-* Markup construction in Scheme::
-* How markups work internally::
-* New markup command definition::
-* New markup list command definition::
+* Beschriftungskonstruktionen in Scheme::
+* Wie Beschriftungen intern funktionieren::
+* Neue Definitionen von Beschriftungsbefehlen::
+* Neue Definitionen von Beschriftungsbefehlen für Listen::
@end menu
-@node Markup construction in Scheme
-@subsection Markup construction in Scheme
+@node Beschriftungskonstruktionen in Scheme
+@subsection Beschriftungskonstruktionen in Scheme
+@translationof Markup construction in Scheme
@cindex Textbeschriftungsbefehle, definieren
@cindex Textbeschriftung, eigene Befehle
eines @code{markup} aufrufen, um Zeichenketten zu manipulieren.
Das ist nützlich, wenn neue Beschriftungsbefehle definiert werden
sollen (siehe auch
-@ref{New markup command definition}).
+@ref{Neue Definitionen von Beschriftungsbefehlen}).
@knownissues
@end lisp
-@node How markups work internally
-@subsection How markups work internally
+@node Wie Beschriftungen intern funktionieren
+@subsection Wie Beschriftungen intern funktionieren
+@translationof How markups work internally
In einer Textbeschriftung wie
@file{scm/@/define@/-markup@/-commands@/.scm}.
-@node New markup command definition
-@subsection New markup command definition
+@node Neue Definitionen von Beschriftungsbefehlen
+@subsection Neue Definitionen von Beschriftungsbefehlen
+@translationof New markup command definition
Neue Textbeschriftungsbefehle können mit dem
@code{define-markup-command}-Scheme-Makro definiert werden.
Scheme Signatur nicht analysiert werden kann.
-@node New markup list command definition
-@subsection New markup list command definition
+@node Neue Definitionen von Beschriftungsbefehlen für Listen
+@subsection Neue Definitionen von Beschriftungsbefehlen für Listen
+@translationof New markup list command definition
Beschriftungslistenbefehle können mit dem Scheme-Makro
@code{define-markup-list-command} definiert werden, welches
sich ähnlich verhält wie das
@code{define-markup-command}-Makro, das schon beschrieben
-wurde in @ref{New markup command definition}. Ein Unterschied
+wurde in @ref{Neue Definitionen von Beschriftungsbefehlen}. Ein Unterschied
ist, dass bei diesem Listen-Makro eine ganze Liste an
Stecils ausgegeben wird.
-@node Contexts for programmers
-@section Contexts for programmers
+@node Kontexte für Programmierer
+@section Kontexte für Programmierer
+@translationof Contexts for programmers
@menu
-* Context evaluation::
-* Running a function on all layout objects::
+* Kontextauswertung::
+* Eine Funktion auf alle Layout-Objekte anwenden::
@end menu
-@node Context evaluation
-@subsection Context evaluation
+@node Kontextauswertung
+@subsection Kontextauswertung
+@translationof Context evaluation
@cindex Aufrufen von Code während der Interpretation
@cindex On-the-fly Code ausführen
-@node Running a function on all layout objects
-@subsection Running a function on all layout objects
+@node Eine Funktion auf alle Layout-Objekte anwenden
+@subsection Eine Funktion auf alle Layout-Objekte anwenden
+@translationof Running a function on all layout objects
@cindex Aufruf von Code für Layoutobjekte
@end lilypond
-@node Scheme procedures as properties
-@section Scheme procedures as properties
+@node Scheme-Vorgänge als Eigenschaften
+@section Scheme-Vorgänge als Eigenschaften
+@translationof Scheme procedures as properties
Eigenschaften (wie Dicke, Richtung usw.) können mit
@code{\override} auf feste Werte gesetzt werden, etwa:
@code{simple-closure}-Objekt.
-@node Using Scheme code instead of \tweak
-@section Using Scheme code instead of @code{\tweak}
+@node Scheme-Code anstelle von \tweak verwenden
+@section Scheme-Code anstelle von @code{ weak} verwenden
+@translationof Using Scheme code instead of \tweak
Der hauptsächliche Nachteil von @code{\tweak} ist seine
syntaktische Inflexibilität. Folgender Code beispielsweise
Durch die Verwendung von Scheme kann dieses Problem umgangen werden.
Der Weg zum Resultat wird gezeigt in
-@ref{Adding articulation to notes (example)}, insbesondere
+@ref{Artikulationszeichen zu Noten hinzufügen (Beispiel)}, insbesondere
wie @code{\displayMusic} benutzt wird, hilft hier weiter.
@example
-@node Difficult tweaks
-@section Difficult tweaks
+@node Schwierige Korrekturen
+@section Schwierige Korrekturen
+@translationof Difficult tweaks
Hier finden sich einige Klassen an schwierigeren Anpassungen.
projects / lilypond.git / blobdiff