From: Till Paala Date: Fri, 7 Aug 2009 21:25:57 +0000 (+0300) Subject: Merge branch 'lilypond/translation' of ssh://git.sv.gnu.org/srv/git/lilypond into... X-Git-Tag: release/2.13.4-1~179^2~151^2~1 X-Git-Url: https://git.donarmstrong.com/?a=commitdiff_plain;h=794dcbdb52faf4292036cd1b0270a956cf4316a3;p=lilypond.git Merge branch 'lilypond/translation' of ssh://git.sv.gnu.org/srv/git/lilypond into lilypond/translation Conflicts: Documentation/de/application/running.itely Documentation/de/macros.itexi --- 794dcbdb52faf4292036cd1b0270a956cf4316a3 diff --cc Documentation/de/application/running.itely index 0000000000,49d8610157..4f9c5d23ac mode 000000,100644..100644 --- a/Documentation/de/application/running.itely +++ b/Documentation/de/application/running.itely @@@ -1,0 -1,705 +1,733 @@@ + @c -*- coding: utf-8; mode: texinfo; documentlanguage: de -*- + + @ignore - Translation of GIT committish: d415427752fa5fd83b0da189d677481d1c7f3043 ++ Translation of GIT committish: 5cf864d550e7148412d594cf336841791bff6f76 + + When revising a translation, copy the HEAD committish of the + version that you are working on. See TRANSLATION for details. + @end ignore + + @c \version "2.12.0" + + @c Translators: Reinhold Kainhofer, Till Rettig + + @node LilyPond starten + @chapter LilyPond starten + @translationof Running LilyPond + + Dieses Kapitel behandelt die technischen Details, wie Lilypond ausgeführt werden kann. + + + @menu + * Übliche Programmbenutzung:: + * Benutzung auf der Kommandozeile:: + * Fehlermeldungen:: + * Dateien mit convert-ly aktualisieren:: + * Fehler melden:: + @end menu + + @node Übliche Programmbenutzung + @section Übliche Programmbenutzung + @translationof Normal usage + + Die meisten Benutzer führen LilyPond von einer graphischen Benutzeroberfläche + aus. Siehe @rlearning{Erste Schritte}, falls Sie dies nicht bereits getan haben. + + + @node Benutzung auf der Kommandozeile + @section Benutzung auf der Kommandozeile + @translationof Command-line usage + + Dieser Abschnitt enthält zusätzliche Informationen, wie Sie LilyPond + von der Kommandozeile ausführen können. Dies kann erforderlich sein, + um etwa zusätzliche Optionen an das Programm zu übergeben. Außerdem + sind einige Zusatzprogramme (wie etwa @code{midi2ly}) nur von der + Kommandozeile verfügbar. + + Unter @q{Kommandozeile} verstehen wir die Kommandozeile des jeweiligen + Betriebssystems. Windows Benutzern ist sie vielleicht eher unter den + englischen Begriffen @q{DOS shell} oder @q{command shell} bekannt. + MacOS@tie{}X Benutzer kennen sie eher unter @q{Terminal} oder @q{Konsole}. + Sie sollten auch den Abschnitt @ref{Einrichtung für MacOS X} konsultieren. + + Wie die Kommandozeile im jeweiligen Betriebssystem benutzt werden kann, + soll in diesem Handbuch nicht näher beschrieben werden. Sehen Sie bitte + im Handbuch Ihres Betriebssystems nach oder informieren Sie sich im + Internet, wenn Sie mit der Kommandozeile nicht vertraut sind. + + + @menu + * lilypond aufrufen:: + * Optionen von lilypond auf der Kommandozeile:: + * Umgebungsvariablen:: + @end menu + + @node lilypond aufrufen + @subsection @command{lilypond} aufrufen + @translationof Invoking lilypond + + @cindex @command{lilypond} aufrufen + @cindex Kommandozeilen-Optionen für @command{lilypond} + @cindex Optionen an der Kommandozeile + + Das @command{lilypond} Programm kann folgendermaßen von der Kommandozeile + aufgerufen werden. + + @example + lilypond [@var{Option}]@dots{} @var{Dateiname}@dots{} + @end example + + + Wird ein @file{Dateiname} ohne Erweiterung angegeben, so wird @file{.ly} als + Standarderweiterung für LilyPond-Dateien benutzt. Um Daten von + @code{stdin} einzulesen, benutzen Sie einfach einen Bindestrich (@code{-}) + als @var{Dateiname}. + + Wenn Lilypond die Datei @file{Dateiname.ly} verarbeitet, werden daraus + die Dateien @file{Dateiname.ps} und @file{Dateiname.pdf} erzeugt. + Es können an @code{lilypond} auch mehrere @file{.ly} Dateien übergeben + werden, die dann einzeln und voneinander unabhängig abgearbeitet + werden.@footnote{Der Zustand von GUILE wird allerdings nicht nach + jeder Datei zurückgesetzt, sodass Achtung geboten ist, wenn in einer + Datei globale Änderungen von Scheme aus durchgeführt werden.} + + Falls @file{Dateiname.ly} mehr als einen @code{\score}-Block enthält, + werden die weiteren Stücke in durchnummerierte Dateien der Form + @file{Dateiname-1.pdf} ausgegeben. Zusätzlich wird der Wert der + Variable @code{output-suffix} zwischen den ursprünglichen Dateienamen + und der Zahl eingefügt. Eine Lilypond-Datei @var{Dateiname.ly} mit dem Inhalt + + @example + #(define output-suffix "Geige") + \score @{ @dots{} @} + #(define output-suffix "Cello") + \score @{ @dots{} @} + @end example + + @noindent + erzeugt daher die Dateien @var{Dateiname}@file{-Geige.pdf} und + @var{Dateiname}@file{-Cello-1.pdf}. + + + + @node Optionen von lilypond auf der Kommandozeile + @subsection Optionen auf der Kommandozeile für @command{lilypond} + @translationof Command line options for lilypond + + Die folgenden Kommandozeilenoptionen werden von @command{lilypond} unterstützt: + + @table @code + + @item -e,--evaluate=@var{expr} + Wertet den Scheme-Ausdruck @var{expr} aus, bevor die @file{.ly} Dateien + gelesen und interpretiert werden. + Die @code{-e} Option kann auch mehrfach angegeben werden, die Ausdrücke + werden nacheinander ausgewertet. + + Da der Ausdruck im @code{guile-user} Modul ausgewertet wird, ist bei der + Definitionen innerhalb von @var{expr} folgendes Vorgehen nötig. An der + Kommandozeile wird z.B. @code{a} im @code{guile-user} Modul definiert: + + @example + lilypond -e '(define-public a 42)' + @end example + + @noindent + Am Beginn der @file{.ly}-Datei muss dann das @code{guile-user} Modul noch geladen werden, bevor die Definition von @var{a} verfügbar ist: + + @example + #(use-modules (guile-user)) + @end example + + + @item -f,--format=@var{Format} + Bestimmt das Ausgabeformat. Mögliche Werte von @var{Format} sind + @code{svg}, @code{ps}, @code{pdf} und @code{png}. + + Beispiel: @code{lilypond -fpng @var{Dateiname}.ly} + + + + @item -d,--define-default=@var{Variable}=@var{Wert} + Damit wird die interne Programmoption @var{Variable} auf den Scheme-Wert + @var{Wert} gesetzt. Wird kein @var{Wert} angegeben, so wird @var{#t} benutzt. + Um eine Option auszuschalten, kann der Präfix @code{no-} dem Namen + @var{Variable} der Variable vorangestellt werden. So ist etwa + + @cindex Point and Click, Kommandozeile + + @example + -dno-point-and-click + @end example + + @noindent + dasselbe wie + @example + -dpoint-and-click='#f' + @end example + + Hier sind ein paar interessante Optionen: + + @table @samp + @item help + Die Ausführung von @code{lilypond -dhelp} zeigt alle verfügbaren @code{-d} + Optionen. + + @item paper-size + Setzt das Standard-Papierformat, + @example + -dpaper-size=\"letter\" + @end example + + @noindent + Die Zeichenkette, die das Format angibt, muss in Anführungszeichen mit Backslash + ( @code{\"} ) stehen. + + + @item safe + Vertraut der @code{.ly} Datei nicht. + + Wenn LilyPond über einen Webserver verfügbar gemacht wird, @b{MUSS} unbedingt + eine die Optionen @code{--safe} oder @code{--jail} angegeben werden. + Die @code{--safe} Option verhindert, dass in der .ly-Datei angegebener + Scheme-Code das System gefährden kann, wie etwa in folgendem Beispiel: + + @quotation + @verbatim + #(system "rm -rf /") + { + c4^#(ly:export (ly:gulp-file "/etc/passwd")) + } + @end verbatim + @end quotation + + Mit der @code{-dsafe} Option werden alle Scheme-Ausdrücke einem speziellen + sicheren Modus ausgewertet. Dieser Modus ist vom GUILE @file{safe-r5rs} Modul + abgeleitet und fügt noch zahlreiche weitere erlaubte Funktionen der + LilyPond Programm-Schnittstelle hinzu. Diese Funktionen sind in + @file{scm/@/safe@/-lily@/.scm} angegeben. + + Zusätzliche verbietet der sichere Modus auch @code{\include} Befehle. + + Im sicheren Modus ist es nicht möglich, LilyPond-Variablen nach Scheme + zu exportieren. + + @code{-dsafe} erkennt jedoch @emph{KEINE} Überbeanspruchung der verfügbaren + Ressourcen. In diesem Modus ist es also trotzdem möglich, dass LilyPond in einer + Endlosschleife hängt, z.B. wenn zyklische Datenstrukturen an das Backend + übergeben werden. Wenn LilyPond also auf einem öffentlich zugänglichen + Webserver verfügbar gemacht wird, sollte der Prozess sowohl in der CPU- + als auch in der Speichernutzung limitiert werden. + + Der sichere Modus verhindert auch, dass zahlreiche nützliche + Musikfragmente von LilyPond verarbeitet werden. Die @code{--jail} Option ist + eine sicherere Alternative, benötigt allerdings auch mehr Aufwand zur + Einrichtung. + + @item backend + Gibt an, welches Ausgabeformat das LilyPond Backend benutzt. Mögliche Werte + für diese Option sind: + + @table @code + @item ps + PostScript-Ausgabeformat. + + @cindex PostScript Ausgabeformat + + Postscript-Dateien enthalten auch TTF-, Type1- und OTF-Schriften. Allerdings + wird die gesamte Schriftart eingefügt und nicht nur die benötigten Zeichen. + Vor allem wenn nicht-westliche Zeichensätze benutzt werden, kann dies zu sehr + großen Dateien führen. + + @item eps + Erzeugt @q{encapsulated PostScript} (EPS). Jede Seite (oder jedes System) wird + als eigene @file{EPS}-Datei ausgegeben, inklusive Schriftarten. Außerdem wird + eine Datei mit allen Seiten (bzw. Systemen) und Schriftarten erzeugt. + + Dies ist die Standardeinstellung von @command{lilypond-book}. + + @item svg + SVG-Ausgabe (Scalable Vector Graphics). Jede Seite wird als eigene + @file{SVG}-Datei ausgegeben, inklusive eingebetteten Schriftarten. + @cindex SVG (Scalable Vector Graphics) + Sie benötigen einen SVG-Betrachter, der eingebettete Schriftarten unterstützt, + oder einen SVG-Betrachter, der eingebettete Schriftarten durch OTF-Schriften + ersetzen kann. In UNIX und Linux kann z.B. @uref{http://www.inkscape.org,Inkscape} + (ab Version 0.42) benutzt werden, nachdem die OTF-Schriften aus dem + LilyPond-Verzeichnis (typischerweise @file{/usr/share/lilypond/VERSION/fonts/otf/}) + in das Verzeichnis @file{~/.fonts/} kopiert wurden. + + @item scm + gibt die rohen Scheme-basierenden Zeichenbefehle aus, wie sie intern von + LilyPond benutzt werden. + + @cindex Scheme dump + + @item null + Keine Partitur wird ausgegeben, hat gleichen Effekt wie @code{-dno-print-pages}. + + @end table + + Beispiel: @code{lilypond -dbackend=svg @var{Dateiname}.ly} + + @cindex Ausgabeformat + + @item preview + Erzeugt eine Ausgabedatei, die nur die Titelzeilen und das erste System + enthält. + + @item print-pages + Erzeugt vollständige Seiten (Standardeinstellung). @code{-dno-print-pages} + ist in Verbindung mit @code{-dpreview} nützlich. + + @end table + + + + @item -h,--help + Zeigt eine Zusammenfassung der Programmbenutzung und der Optionen. + + @item -H,--header=@var{FELD} + Gibt den Inhalt eines Feldes aus dem @code{\header}-Block in die Datei + @file{Dateiname.@var{FELD}} aus. + + @item --include, -I=@var{Verzeichnis} + Fügt @var{Verzeichnis} zur Liste der Suchpfade hinzu. + @cindex Dateisuche + @cindex Suchpfad + + @item -i,--init=@var{Initialisierungsdatei} + Benutzt @var{Initialisierungsdatei} zur gesamten Programminitialisierung. Der + Standardwert ist @file{init.ly}. + + @item -o,--output=@var{DATEI} + Schreibt das Ergebnis der Verarbeitung mit LilyPond in die Ausgabedatei + @var{DATEI}. Die entsprechende Dateinamenserweiterung wird angehängt (z.B. + @code{.pdf} für pdf). + + @item --ps + Erzeugt PostScript. + + @item --png + Erzeugt eine Grafik-Datei im PNG-Format von jeder Seite. Diese Option + impliziert auch @code{--ps}. Die Auflösung in DPI der Grafik kann festgelegt + werden durch + @example + -dresolution=110 + @end example + + @item --pdf + Erzeugt PDF-Dateien. Dies impliziert @code{--ps}. + + @item -j,--jail=@var{Benutzer},@var{Gruppe},@var{Jail-Verzeichnis},@var{Arbeitsverzeichnis} + Führt @command{lilypond} in einem chroot-Jail aus. + + Die @code{--jail} Option ist eine flexiblere Alternative zu @code{--safe}, wenn + LilyPond über das Internet verfügbar gemacht wird oder LilyPond-Quelldateien + von Dritten automatisch vararbeitet werden. + + Sie funktioniert dergestalt, dass das Wurzelverzeichnis von + @command{lilypond} auf @var{Jail-Verzeichnis} gesetzt wird, bevor die + tatsächliche Kompilierung der .ly-Datei beginnt. Der Benutzer und die Gruppe + werden auf die angegebenen Werte gesetzt und das aktuelle Arbeitsverzeichnis + wird ebenfalls auf den angegebenen Wert @var{Arbeitsverzeichnis} gesetzt. + Diese Einstellungen garantieren (zumindest in der Theorie), dass es nicht + möglich ist, aus dem Jail auszubrechen. Damit @code{--jail} funktioniert, muss + @command{lilypond} allerdings als root ausgeführt werden, was normalerweise + auf sichere Art mit dem Kommando @command{sudo} erreicht werden kann. + + Das Jail-Verzeichnis zu erstellen ist etwas heikel, da LilyPond alle zur + Ausführung nötigen Bibliotheken und Dateien @emph{innerhalb des + Jail-Verzeichnisses} finden muss. Ein typisches Setup besteht aus folgenden + Punkten: + + @table @asis + @item Erstellung eines getrennten Dateisystems + Ein eigenes Dateisystem muss für LilyPond erstellt werden, sodass es mit + sicheren Einstellungen wie @code{noexec}, @code{nodev} und @code{nosuid} + eingebunden werden kann. Damit ist es unmöglich, Programme von diesem + Dateisystem auszuführen oder direkt auf eine Hardware-Schnittstelle + zuzugreifen. Wenn Sie keine eigene Partition erstellen möchten, können Sie + auch eine Datei der entsprechenden Größe erstellen und sie als @q{loop}-Gerät + einbinden. Ein getrenntes Dateisystem garantiert auch, dass LilyPond nicht + mehr Festplattenspeicher benutzt als erlaubt. + + @item Erstellung eines eigenen Benutzerkontos + Es sollte ein eigener Benutzer und eine eigene Gruppe (z. B. + @code{lily}/@code{lily}) mit geringen Rechten für die Ausführung von LilyPond + innerhalb des Jails benutzt werden. Nur ein einziges Verzeichnis des Jails sollte + für den Benutzer schreibbar sein und als @var{Arbeitsverzeichnis} an + @code{lilypond} übergeben werden. + + @item Einrichtung des Jails + LilyPond muss zahlreiche Dateien für die Ausführung einlesen. All diese + Dateien müssen in das Jail-Verzeichnis kopiert werden (mit denselben Pfaden + wie im tatsächlichen Wurzel-Dateisystem). Die gesamte LilyPond-Installation + (typischerweise @file{/usr/share/lilypond}) sollte kopiert werden. + + Falls Probleme auftreten, ist es am einfachsten, Lilypond mittels + @command{strace} zu starten, wodurch Sie relativ leicht feststellen können, + welche Dateien im Jail noch fehlen. + + @item Ausführung von LilyPond + In einem mit @code{noexec} eingebundenen Jail ist es nicht möglich, externe + Programme auszuführen. Daher muss LilyPond auf eine Art gestartet werden, + die keine weitere Ausführung von Programmen benötigt. Wie bereits erwähnt + muss LilyPond mit Administrator-Rechten gestartet werden (die es allerdings + sofort wieder abgibt), beispielsweise mittels @command{sudo}. Außerdem + ist es eine gute Idee, die LilyPond zur Verfügung stehende CPU-Zeit zu + limitieren (z. B. mit @command{ulimit -t}) und -- falls das Betriebssystem + dies unterstützt -- auch den zur Verfügung stehenden Hauptspeicher. + @end table + + + @item -v,--version + Gibt die Versionsnummer aus. + + @item -V,--verbose + Gibt ausführliche informative Meldungen aus: Zeigt die vollen Dateipfade + aller gelesenen Dateien sowie Informationen über die Laufzeit. + + @item -w,--warranty + Zeigt die Garantiebedingungen an, unter denen GNU LilyPond steht. (Es besteht + @strong{KEINERLEI GARANTIE}!) + @end table + + + @node Umgebungsvariablen + @subsection Umgebungsvariablen + @translationof Environment variables + + @cindex LANG + @cindex LILYPOND_DATADIR + + @command{lilypond} erkennt und benützt die folgenden Umgebungsvariablen: + @table @code + @item LILYPOND_DATADIR + Diese Variable gibt das Verzeichnis an, wo Lilypond seine eigenen Dateien, + Meldungen und Übersetzungen finden kann. Dieses Verzeichnis sollte + Unterverzeichnisse @file{ly/}, @file{ps/}, @file{tex/}, etc. beinhalten. + + @item LANG + Gibt die Sprache an, in der Warnungen und Fehlermeldungen ausgegeben werden. + + @item LILYPOND_GC_YIELD + Mit dieser Variable (mit Werten zwischen 0 und 100) kann die Feinabstimmung + zwischen dem Bedarf an Hauptspeicher und Rechenleistung bei der Ausführung + von LilyPond durchgeführt werden. Bei höheren Werten benutzt LilyPond + mehr Hauptspeicher, benötigt aber weniger Prozessor-Leistung. Bei + niedrigeren Werten wird mehr Prozessor-Zeit, dafür weniger Hauptspeicher + benötigt. Voreinstellung ist ein Wert von @code{70}. + + @end table + + + @node Fehlermeldungen + @section Fehlermeldungen + @translationof Error messages + + @cindex error messages + Während der Verarbeitung einer Dateien können diverse Meldungen an der + Kommandozeile auftreten: + + @table @emph + + @item Warnung + @cindex Warnung + Irgendetwas ist verdächtig. Wenn Sie etwas Ungewöhnliches in Ihrer + Datei durchführen, dann werden Sie die Meldung verstehen und können + sie gegebenenfalls ignorieren. Im Normalfall jedoch bedeutet eine + Warnung, dass mit Ihrer Datei etwas nicht stimmt, LilyPond jedoch + trotzdem versucht, die Datei soweit wie möglich korrekt zu übersetzen. + + @item Fehler + @cindex Fehler + Irgendetwas stimmt definitiv nicht. Der aktuelle Bearbeitungsschritt + (Einlesen, Interpretieren oder Formatieren der Datei) wird noch fertig + ausgeführt, danach bricht die Bearbeitung aber ab. + + @item Fataler Fehler + @cindex Fataler Fehler + Irgendetwas stimmt definitiv nicht und LilyPond kann nicht weiter + ausgeführt werden. Dies ist nur sehr selten der Fall, meist sind + die Schriftarten nicht korrekt installiert. + + @item Scheme Fehler + @cindex Fehlerprotokoll, Scheme + @cindex Scheme Fehler + Fehler, die während der Ausführung von Scheme-Code auftreten, werden + vom Scheme-Interpreter aufgefangen und an der Kommandozeile ausgegeben. + Wenn Sie LilyPond mit der @code{--verbose} Option (auch @code{-V}) + ausführen, wird der sogennante @q{Call trace} ausgegeben, der die + aufgerufenen Funktionen zur Zeit des Fehlers angibt. + + @item Programmierfehler + @cindex Programmierfehler + Eine interne Inkonsistenz ist aufgetreten. Diese Fehlermeldungen + sollen den Programmierern die Fehlersuche erleichtern und + können meistens einfach ignoriert werden. In manchen Fällen werden + so viele Meldungen ausgegeben, dass die Lesbarkeit der restliche + Ausgabe davon beeinträchtigt wird. + + @item Abgebrochen (core dumped) + Dies bezeichnet einen ernsten Programmierfehler, der das Programm + zum Absturz gebracht hat. Solche Fehler werden als kritisch angesehen. + Falls daher einer auftritt, senden Sie bitte einen Bug-Report! + @end table + + @cindex Fehlermeldung, Format + @cindex Form der Fehlermeldungen + Wenn Warnungen oder Fehlermeldungen mit einer konkreten Stelle in der + Eingabedatei verknüpft werden können, dann hat die Meldung die folgende + Form: + + @example + @var{Dateiname}:@var{Zeile}:@var{Spalte}: @var{Meldung} + @var{Fehlerhafte Eingabezeile} + @end example + + Ein Zeilenumbruch wird in der fehlerhaften Zeile an jener Stelle eingefügt, + wo der Fehler aufgetreten ist. Zum Beispiel + + @example + test.ly:2:19: Fehler: keine gültige Dauer: 5 + @{ c'4 e' + 5 g' @} + @end example + + Diese Stellen sind LilyPonds Vermutung, wo die Warnung oder der Fehler + aufgetreten ist, allerdings treten Warnungen und Fehler ja gerade in + unerwarteten Fällen auf. Manchmal kann Lilypond auch eine fehlerhafte + Stelle zwar noch problemlos verarbeiten, ein paar Zeilen später wirkt + sich der Fehler aber dann doch noch aus. In solchen Fällen, wo Sie in + der angegebenen Zeile keinen Fehler erkennen, sollten Sie auch die Zeilen + oberhalb der angegebenen Stelle genauer unter die Lupe nehmen. + + + @node Dateien mit convert-ly aktualisieren + @section Dateien mit @command{convert-ly} aktualisieren + @translationof Updating files with convert-ly + + @cindex Aktualisierung von LilyPond-Dateien + @cindex Aktualisierung mit convert-ly + @cindex convert-ly: Aktualisierung + + Die Eingabesyntax von LilyPond ändert sich graduell um etwa die + Eingabe zu erleichtern oder neue Funktionen zu ermöglichen. Ein + Nebeneffekt hiervon ist, dass das LilyPond-Übersetzerprogramm nicht + mehr mit älteren Eingabedateien kompatibel sein kann. Um dies + zu umgehen, kann @command{convert-ly} benutzt werden, welches die + meisten der Syntaxänderungen korrigieren kann. + + Das Programm benötigt eine @code{\version}-Information in der + Eingabedatei, um zu wissen, von welcher Version konvertiert werden + soll. In den meisten Fällen genügt es, den Befehl + + @example + convert-ly -e meineDatei.ly + @end example + + @noindent + auszuführen. -@c MacOS@tie{}X-Benutzer können diesen Befehl im Menu unter -@c @code{Compile > Update syntax} finden. -@c Does it work? TR + -Wenn keine Veränderungen in @code{meineDatei.ly} vorgenommen wurden -und eine Datei @code{meineDatei.ly.NEW} erstellt wird, it -@code{meineDatei.ly} schon aktuell. ++Damit wird @code{meineDatei.ly} direkt aktualisiert und die ++Originaldatei unter @code{meineDatei.ly~} gespeichert. ++ ++Alternativ kann man der aktualisierten Datei auch einen anderen ++Namen geben, in welchem Fall die Originaldatei unverändert ++gelassen wird. Das geht mit dem Befehl ++ ++@example ++convert-ly meineDatei.ly > meineneueDatei.ly ++@end example ++ ++Das Programm zeigt die Versionsnummern an, für die Konvertierungen ++vorgenommen wurden. Wenn keine Versionsnummern angezeigt werden, ++ist die Datei schon aktuell. ++ ++ ++MacOS@tie{}X-Benutzer können diesen Befehl im Menu unter ++@code{Compile > Update syntax} finden. ++ ++Benutzer unter Windows müssen diesen Befehl auf der Eingabeaufforderung ++schreiben, welche man üblicherweise unter dem Menüeintrag ++@code{Start > Alle Programme > Zubehör > Eingabeaufforderung} zu ++finden ist. + + + @menu + * Optionen von convert-ly auf der Kommandozeile:: + * Probleme mit convert-ly:: + @end menu + ++ + @node Optionen von convert-ly auf der Kommandozeile + @subsection Optionen von @command{convert-ly} auf der Kommandozeile + @translationof Command line options for convert-ly + + @command{convert-ly} konvertiert immer bis zur letzten Syntaxänderung, + die es beherrscht. Das heißt, dass die neue @code{version}-Nummer + in der Datei überlicherweise etwas niedriger ist als die + Version von @command{convert-ly}. + -Um LilyPond-Fragmente in texinfo-Dateien zu aktualisieren, gilt -der Befehl: - -@example -convert-ly --from=... --to=... --no-version *.itely -@end example - -Um die Änderungen der LilyPond-Syntax zwischen bestimmten Versionen -zu sehen, kann der Befehl - -@example -convert-ly --from=... --to=... -s -@end example - -@noindent -benutzt werden. - -Viele Dateien können auf einmal aktualisiert werden, indem -@code{convert-ly} mit den üblichen UNIX-Befehlen kombiniert -wird. Das folgende Beispiel aktualisiert alle @code{.ly}-Dateien -im aktuellen Verzeichnis: - -@example -for f in *.ly; do convert-ly -e $f; done; -@end example - + Die allgemeine Syntax des Programms lautet: + + @example -convert-ly [@var{option}]@dots{} @var{file}@dots{} ++convert-ly [@var{Option}]@dots{} @var{Dateiname}@dots{} + @end example + + Folgende Optionen sind möglich: + + @table @code + @item -e,--edit -Verändere die entsprechende Zeile der Eingabedatei. Überschreibt -@code{--output}. ++Führt die Aktualisierung direkt in der Datei durch, die Datei wird ++dabei verändert. + + @item -f,--from=@var{von-Versionsnummer} + Setze die Version, ab welcher konvertiert werden soll. Wenn diese + Option nicht gesetzt ist, versucht @command{convert-ly}, die + Version auf Grundlage von @code{\version} zu raten. ++Beispiel: @code{--from=2.10.25} + + @item -n,--no-version + Normalerweise fügt @command{convert-ly} eine @code{\version}-Zeile + zur Ausgabe hinzu. Mit dieser Option kann das unterdrückt werden. + + @item -s, --show-rules + Zeige alle bekannten Konversionsregeln und beende. + + @item --to=@var{bis-Versionsnummer} + Hiermit kann das Ziel der Konversion gesetzt werden. Standard ist -die neueste mögliche Version. ++die neueste mögliche Version. Beispiel: @code{--to=2.12.2} + + @item -h, --help + Benutzerhilfe ausgeben. + @end table + ++Um LilyPond-Fragmente in texinfo-Dateien zu aktualisieren, gilt ++der Befehl: ++ ++@example ++convert-ly --from=... --to=... --no-version *.itely ++@end example ++ ++Um die Änderungen der LilyPond-Syntax zwischen bestimmten Versionen ++zu sehen, kann der Befehl ++ ++@example ++convert-ly --from=... --to=... -s ++@end example ++ ++@noindent ++benutzt werden. ++ ++Viele Dateien können auf einmal aktualisiert werden, indem ++@code{convert-ly} mit den üblichen UNIX-Befehlen kombiniert ++wird. Das folgende Beispiel aktualisiert alle @code{.ly}-Dateien ++im aktuellen Verzeichnis: ++ ++@example ++for f in *.ly; do convert-ly -e $f; done; ++@end example ++ ++ + + @node Probleme mit convert-ly + @subsection Probleme mit @code{convert-ly} + @translationof Problems with convert-ly + ++Wenn convert-ly unter Windows auf der Eingabeaufforderung mit einer ++Datei benutzt wird, deren Name oder Pfad Leerzeichen enthält, muss ++der gesamte Dateipfad mit drei (!) Anführungszeichen umgeben werden: ++ ++@example ++convert-ly """D:/My Scores/Ode.ly""" > """D:/My Scores/new Ode.ly""" ++@end example ++ + Nicht alle Änderungen der Syntax können konvertiert werden. Nur + eine Ausgabeoption kann angegeben werden. Scheme- und + LilyPond-Scheme-Code wird sehr unwahrscheinlich korrekt aktualisiert, + hier ist meistens Nacharbeit erforderlich. + + @verbatim + Hier eine Liste einiger Befehle, die convert-ly nicht konvertieren kann. + + Diese Liste ist in Form von Fehlermeldungen, denn convert-ly + ist so strukturiert, dass nicht alle benötigten Änderungen + implementiert werden können. Es handelt sich also eher um eine + Wunschliste zur Referenz. + + 1.6->2.0: + Bezifferter Bass wird nicht immer korrekt konvertiert, besonders + Befehle wie {< >}. Mats Kommentar hierzu: + Um convert-ly korrekt ausführen zu können, müssen alle Vorkommen + von '{<' in etwas beliebiges wie '{#' und genauso '>}' in '&}' + geändert werden. Nach der Konversion können sie dann zurück + in '{ <' und '> }' verwandelt werden + Nicht alle Textbeschriftungen werden richtig konvertiert. In der + alten Syntax konnten Beschriftungsbefehle mit Klammern gruppiert + werden, etwa + -#'((bold italic) "string") + This will incorrectly be converted into + -\markup{{\bold italic} "string"} + instead of the correct + -\markup{\bold \italic "string"} + 2.0->2.2: + \partcombine wird nicht konvertiert + \addlyrics => \lyricsto wird nicht konvertiert, dadurch kompilieren + manche Dateien mit mehreren Strophen nicht. + 2.0->2.4: + \magnify wird nicht nach \fontsize konvertiert. + - \magnify #m => \fontsize #f, where f = 6ln(m)/ln(2) + remove-tag wird nicht verändert. + - \applyMusic #(remove-tag '. . .) => \keepWithTag #'. . . + first-page-number wird nicht geändert. + - first-page-number no => print-first-page-number = ##f + Zeilenumbrüche im \header-Feld werde nicht konvertiert. + - \\\\ als Zeilenumbruch in \header{...} => \markup \center-align < + "First Line" "Second Line" > + Crescendo- und Decrescendo-Enden werden nicht konvertiert. + - \rced => \! + - \rc => \! + 2.2->2.4: + \turnOff (in \set Staff.VoltaBracket = \turnOff eingesetzt) wird nicht korrekt behandelt. + 2.4.2->2.5.9 + \markup{ \center-align <{ ... }> } sollte umgewandelt werden in: + \markup{ \center-align {\line { ... }} } + aber im Moment fehlt \line. + 2.4->2.6 + Besondere LaTeX-Zeichen wie $~$ im Text werden nicht nach UTF( + konvertiert. + 2.8 + \score{} muss jetzt mit einem musikalischen Ausdruck beginnen. + Alles andere (insbesondere \header{}) darf erst nach den Noten + kommen. + @end verbatim + + + + @node Fehler melden + @section Fehler melden + @translationof Reporting bugs + + + @cindex Fehler + @cindex Fehler melden + + Wenn Sie eine Datei haben, die zu einem Absturz von LilyPond oder zu einer + fehlerhaften Ausgabe führt, so ist dies ein @q{Bug}. Die List der aktuell + bekannten derartigen Fehler findet sich in unserem @q{Google Bug Tracker}: + + @uref{http://code.google.com/p/lilypond/issues/list} + + Wenn Sie einen Fehler gefunden haben, der noch nicht aufgelistet ist, melden + Sie dies bitte anhand der Anweisungen auf der Seite + + @uref{http://lilypond.org/web/devel/participating/bugs} + + Wenn Sie Beispieldateien für den Fehler erstellen, versuchen Sie bitte, die + Datei möglichst minimal zu halten und nur jenen LilyPond Code aufzunehmen, + der auch wirklich für den Fehler verantwortlich ist. Meldungen mit + Beispieldateien, die nicht minimal sind, können wir meist aus Zeitgründen + nicht effektiv bearbeiten. + diff --cc Documentation/de/learning/scheme-tutorial.itely index 0000000000,8951a43acf..35bd95de3b mode 000000,100644..100644 --- a/Documentation/de/learning/scheme-tutorial.itely +++ b/Documentation/de/learning/scheme-tutorial.itely @@@ -1,0 -1,298 +1,349 @@@ + @c -*- coding: utf-8; mode: texinfo; documentlanguage: de -*- + + @ignore - Translation of GIT committish: 5131c3292d30cabdf08839daa02a006e4d3c96c5 ++ Translation of GIT committish: 5cf864d550e7148412d594cf336841791bff6f76 + + When revising a translation, copy the HEAD committish of the + version that you are working on. See TRANSLATION for details. + @end ignore + + @c \version "2.12.0" + + @node Scheme-Übung + @appendix Scheme-Übung + @translationof Scheme tutorial + + @funindex # + @cindex Scheme + @cindex GUILE + @cindex Scheme, in einer LilyPond-Datei + @cindex LISP + + LilyPond verwendet die Scheme-Programmiersprache sowohl als Teil + der Eingabesyntax als auch als internen Mechanismus, um Programmmodule + zusammenzufügen. Dieser Abschnitt ist ein sehr kurzer Überblick über + die Dateneingabe mit Scheme. Wenn Sie mehr über Scheme wissen wollen, + gehen Sie zu @uref{http://@/www@/.schemers@/.org}. + ++LilyPond benutzt die GNU Guile-Implementation von Scheme, die auf dem ++@qq{R5RS}-Standard von Scheme basiert. Wenn Sie Scheme lernen wollen, ++um es innerhalb von LilyPond zu benutzen, wird es nicht empfohlen, ++mit einer anderen Implementation (die sich auf einen anderen ++Standard bezieht) zu arbeiten. Information zu Guile findet sich ++unter @uref{http://www.gnu.org/software/guile/}. Der ++@qq{R5RS}-Standard von Scheme befindet sich unter der Adresse ++@uref{http://www.schemers.org/Documents/Standards/R5RS/}. ++ ++Die LilyPond-Installation enthält gleichzeitig auch die ++Guile-Implemenation von Scheme. Auf den meisten Systemen kann ++man in einer Scheme-sandbox experimentieren, indem man ein ++Kommandozeilen-Fenster öffnet und @code{guile} auffruft. Unter ++einigen Systemen, insbesondere unter Windows, muss man evtl. ++die Umgebungsvariable @code{GUILE_LOAD_PATH} auf das Verzeichnis ++@code{../usr/shr/guile/1.8} innerhalb des LilyPond-Installationsverzeichnisses ++setzen (der vollständige Pfad ist erklärt in @ref{Other sources of information}). ++Alternativ können Windows-Benutzer auch einfach @qq{Ausführen} im ++Startmenü wählen und @code{guile} schreiben. ++ + Das Grundlegendste an einer Sprache sind Daten: Zahlen, Zeichen, -Zeichenketten, Listen usw. Hier ist eine Liste der Datentypen, die für ++Zeichenketten, Listen usw. Hier ist eine Liste der Datentypen, die für + LilyPond-Eingabedateien relevant sind. + + @table @asis + @item Boolesche Variablen + Werte einer Booleschen Variable sind Wahr oder Falsch. Die Scheme-Entsprechung + für Wahr ist @code{#t} und für Falsch @code{#f}. + @funindex ##t + @funindex ##f + + @item Zahlen + Zahlen werden wie üblich eingegeben, @code{1} ist die (ganze) + Zahl Eins, während @code{-1.5} ist eine Gleitkommazahl (also + eine nicht-ganze). + + @item Zeichenketten + Zeichenketten werden in doppelte Anführungszeichen gesetzt: + + @example + "Das ist eine Zeichenkette" + @end example + + Zeichenketten können über mehrere Zeilen reichen: + + @example + "Das + ist + eine Zeichenkette" + @end example + + Anführungszeichen und neue Zeilen können auch mit sogenannten + Fluchtsequenzen eingefügt werden. Die Zeichenkette + @code{a sagt "b"} wird wie folgt eingegeben: + + @example + "a sagt \"b\"" + @end example + + Neue Zeilen und Backslashe werden mit @code{\n} bzw. @code{\\} + eingegeben. + @end table + + In einer Notationsdatei werden kleine Scheme-Abschnitte mit der + Raute (@code{#}) eingeleitet. Die vorigen Beispiele heißen also in + LilyPond: + + @example + ##t ##f + #1 #-1.5 + #"Das ist eine Zeichenkette" + #"Das + ist + eine Zeichenkette" + @end example + ++LilyPond-Kommentare (@code{%} oder @code{%@{ %@}}) können innerhalb ++von Scheme-Code nicht benutzt werden. Kommentare in Guile Scheme ++werden wie folgt notiert: ++ ++@example ++; Einzeiliges Kommentar ++ ++#! ++ Guile-Stil Blockkommentar (nicht schachtelbar) ++ Diese Kommentare werden von Scheme-Programmierern ++ selten benutzt und nie im Quellcode ++ von LilyPond ++!# +++@end example ++ ++Merere aufeinander folgende Scheme-Ausdrücke in einer Notationsdatei ++können kombiniert werden, wenn man @code{begin} einsetzt. Das ++erlaubt es, die Anzahl an Rauten auf eins zu begrenzen. ++ ++@example ++#(begin ++ (define foo 0) ++ (define bar 1)) ++@end example ++ ++Wenn @code{#} von einer öffnenden Klammer, @code{(}, gefolgt wird, wie ++in dem Beispiel oben, bleibt der Parser im Scheme-Modus bis eine ++passende schließende Klammer, @code{)}, gefunden wird, sodass keine ++weiteren @code{#}-Zeichen benötigt werden, um einen Scheme-Abschnitt ++anzuzeigen. ++ + Für den Rest dieses Abschnitts nehmen wir an, dass die Daten immer in + einer LilyPond-Datei stehen, darum wird immer die Raute verwendet. + + Scheme kann verwendet werden, um Berechnungen durchzuführen. Es + verwendet eine @emph{Präfix}-Syntax. Um 1 und@tie{}2 zu addieren, muss + man @code{(+ 1 2)} schreiben, und nicht @math{1+2}, wie in traditioneller + Mathematik. + + @lisp + #(+ 1 2) + @result{} #3 + @end lisp + + Der Pfeil @result{} zeigt an, dass das Ergebnis der Auswertung von + @code{(+ 1 2)} @code{3}@tie{}ist. Berechnungen können geschachtelt + werden und das Ergebnis einer Berechnung kann für eine neue + Berechnung eingesetzt werden. + + @lisp + #(+ 1 (* 3 4)) + @result{} #(+ 1 12) + @result{} #13 + @end lisp + + Diese Berechnungen sind Beispiele von Auswertungen. Ein Ausdruck + wie @code{(* 3 4)} wird durch seinen Wert @code{12} ersetzt. Ähnlich + verhält es sich mit Variablen. Nachdem eine Variable definiert ist: + + @example + zwoefl = #12 + @end example + + @noindent + kann man sie in Ausdrücken weiterverwenden: + + @example + vierundzwanzig = #(* 2 zwoelf) + @end example + + @noindent + Die 24 wird in der Variablen @code{vierundzwanzig} gespeichert. + Die gleiche Zuweisung kann auch vollständig in Scheme geschrieben + werden: + + @example + #(define vierundzwanzig (* 2 zwoelf)) + @end example + + Der @emph{Name} einer Variable ist auch ein Ausdruck, genauso wie + eine Zahl oder eine Zeichenkette. Er wird wie folgt eingegeben: + + @example + #'vierundzwanzig + @end example + + @funindex #'symbol + @cindex Zitieren in Scheme + + Das Apostroph @code{'} verhindert, dass bei der Scheme-Auswertung + @code{vierundzwanzig} durch @code{24} ersetzt wird. Anstatt dessen erhalten + wir die Bezeichnung @code{vierundzwanzig}. + + Diese Syntax wird sehr oft verwendet, weil es manche + Einstellungsveränderungen erfordern, dass Scheme-Werte einer + internen Variable zugewiesen werden, wie etwa + + @example + \override Stem #'thickness = #2.6 + @end example + + Diese Anweisung verändert die Erscheinung der Notenhälse. Der Wert + @code{2.6} wird der Variable @code{thickness} (Dicke) eines + @code{Stem}-(Hals)-Objektes gleichgesetzt. + @code{thickness} wird relativ zu den Notenlinien errechnet, in diesem + Fall sind die Hälse also 2,6 mal so dick wie die Notenlinien. Dadurch + werden Hälse fast zweimal so dick dargestellt, wie sie normalerweise sind. + Um zwischen Variablen zu unterscheiden, die in den Quelldateien direkt + definiert werden (wie @code{vierundzwanzig} weiter oben), und zwischen denen, + die für interne Objekte zuständig sind, werden hier die ersteren + @qq{Bezeichner} genannt, die letzteren dagegen @qq{Eigenschaften}. + Das Hals-Objekt hat also eine @code{thickness}-Eigenschaft, während + @code{vierundzwanzig} ein Bezeichner ist. + + @cindex Eigenschaften versus Bezeichner + @cindex Bezeichner versus Eigenschaften + + Sowohl zweidimensionale Abstände (X- und Y-Koordinaten) als auch + Größen von Objekten (Intervalle mit linker und rechter Begrenzung) werden + als @code{pairs} (Paare) eingegeben. Ein Paar@footnote{In der + Scheme-Terminologie wird ein Paar @code{cons} genannt und seine + zwei Elemente @code{car} und @code{cdr}.} wird als @code{(erster . zweiter)} + eingegeben und sie müssen mit dem Apostroph eingeleitet werden, genauso + wie Symbole: + + @example + \override TextScript #'extra-offset = #'(1 . 2) + @end example + + Hierdurch wird das Paar (1, 2) mit der Eigenschaft @code{extra-offset} + des TextScript-Objektes verknüpft. Diese Zahlen werden in + Systembreiten gemessen, so dass der Befehl das Objekt eine Systembreite + nach rechts verschiebt und zwei Breiten nach oben. + + Die zwei Elemente eines Paares können von beliebigem Inhalt sein, etwa + + @example + #'(1 . 2) + #'(#t . #f) + #'("blah-blah" . 3.14159265) + @end example + + Eine Liste wird eingegeben, indem die Elemente der Liste in Klammern + geschrieben werden, mit einem Apostroph davor. Beispielsweise: + + @example + #'(1 2 3) + #'(1 2 "string" #f) + @end example + + Die ganze Zeit wurde hier schon Listen benutzt. Eine Berechnung, + wie @code{(+ 1 2)}, ist auch eine Liste (welche das Symbol @code{+} + und die Nummern 1 und@tie{}2 enthält. Normalerweise werden Listen + als Berechnungen interpretiert und der Scheme-Interpreter ersetzt + die Liste mit dem Ergebnis der Berechnung. Um eine Liste an sich + einzugeben, muss die Auswertung angehalten werden. Das geschieht, + indem der Liste ein Apostroph vorangestellt wird. Für Berechnungen + kann man also den Apostroph nicht verwenden. + + Innerhalb einer zitierten Liste (also mit Apostroph) muss man keine + Anführungszeichen mehr setzen. Im Folgenden ein Symbolpaar, eine + Symbolliste und eine Liste von Listen: + + @example + #'(stem . head) + #'(staff clef key-signature) + #'((1) (2)) + @end example + + + + @menu + * Optimierungen mit Scheme:: + @end menu + + @node Optimierungen mit Scheme + @appendixsec Optimierungen mit Scheme + @translationof Tweaking with Scheme + + Wir haben gesehen wie LilyPond-Eingabe massiv beeinflusst + werden kann, indem Befehle wie etwa + @code{\override TextScript #'extra-offset = ( 1 . -1)} + benutzt werden. Aber es wurde gezeigt, dass Scheme noch + mächtiger ist. Eine bessere Erklärung findet sich in der@ref{Scheme-Übung} und in + @ruser{Schnittstellen für Programmierer}. + + Scheme kann auch in einfachen @code{\override}-Befehlen + benutzt werden: + + TODO Find a simple example + @c This isn't a valid example with skylining + @c It works fine without padText -td + + @ignore + @lilypond[quote,verbatim,ragged-right] + padText = #(define-music-function (parser location padding) (number?) + #{ + \once \override TextScript #'padding = #$padding + #}) + + \relative c''' { + c4^"piu mosso" b a b + \padText #1.8 + c4^"piu mosso" d e f + \padText #2.6 + c4^"piu mosso" fis a g + } + @end lilypond + @end ignore + + Es kann auch benutzt werden, um Befehle zu erstellen: + + @c Check this is a valid example with skylining + @c It is - 'padding still works + + @lilypond[quote,verbatim,ragged-right] + tempoPadded = #(define-music-function (parser location padding tempotext) + (number? string?) + #{ + \once \override Score.MetronomeMark #'padding = $padding + \tempo \markup { \bold $tempotext } + #}) + + \relative c'' { + \tempo \markup { "Low tempo" } + c4 d e f g1 + \tempoPadded #4.0 #"High tempo" + g4 f e d c1 + } + @end lilypond + + Sogar ganze Musikausdrücke können eingefügt werden: + + @lilypond[quote,verbatim,ragged-right] + pattern = #(define-music-function (parser location x y) (ly:music? ly:music?) + #{ + $x e8 a b $y b a e + #}) + + \relative c''{ + \pattern c8 c8\f + \pattern {d16 dis} { ais16-> b\p } + } + @end lilypond + + diff --cc Documentation/de/learning/tweaks.itely index 0000000000,c0f4b7d8c4..ff8a6d23d0 mode 000000,100644..100644 --- a/Documentation/de/learning/tweaks.itely +++ b/Documentation/de/learning/tweaks.itely @@@ -1,0 -1,4099 +1,4109 @@@ + @c -*- coding: utf-8; mode: texinfo; documentlanguage: de -*- + + @ignore - Translation of GIT committish: d96023d8792c8af202c7cb8508010c0d3648899d ++ Translation of GIT committish: 5cf864d550e7148412d594cf336841791bff6f76 + + When revising a translation, copy the HEAD committish of the + version that you are working on. See TRANSLATION for details. + @end ignore + + @c \version "2.12.0" + + @node Die Ausgabe verändern + @chapter Die Ausgabe verändern + @translationof Tweaking output + + In diesem Kapitel wird erklärt, wie man die Notenausgabe verändern + kann. In LilyPond kann man sehr viel konfigurieren, fast jedes + Notenfragment kann geändert werden. + + + @menu + * Grundlagen für die Optimierung:: + * Die Referenz der Programminterna:: + * Erscheinung von Objekten:: + * Positionierung von Objekten:: + * Kollision von Objekten:: + * Weitere Optimierungen:: + @end menu + + + @node Grundlagen für die Optimierung + @section Grundlagen für die Optimierung + @translationof Tweaking basics + + @menu + * Grundlagen zur Optimierung:: + * Objekte und Schnittstellen:: + * Regeln zur Benennung von Objekten und Eigenschaften:: + * Optimierungsmethoden:: + @end menu + + @node Grundlagen zur Optimierung + @subsection Grundlagen zur Optimierung + @translationof Introduction to tweaks + + @qq{Optimierung} (engl. tweaking) ist ein LilyPond-Begriff für die + verschiedenen Methoden, die Aktionen zu beeinflussen, die während + der Kompilation einer Notationsdatei vorgenommen werden sowie auf + das Notenbild einzuwirken. Einige dieser Opitmierungen sind sehr + einfach, andere dagegen recht komplex. Aber insgesamt erlaubt das + System an Optimierungen so gut wie alle möglichen Erscheindungsformen + für die Notenausgabe. + + In diesem Abschnitt werden die grundlegenden Konzepte vorgestellt, + um die Optimierung zu verstehen. Später soll eine Anzahl von fertigen + Befehlen bereitgestellt werden, die einfach in die Quelldatei + kopiert werden können um den selben Effekt wie im Beispiel + zu erhalten. Gleichzeitig zeigen diese Beispiele, wie die Befehle + konstruiert werden, so dass Sie in der Lage sein werden, eigene + Befehle auf dieser Grundlage zu entwickeln. + + Bevor Sie mit diesem Kapitel beginnen, könnte Sie ein Blick in den + Abschnitt @ref{Kontexte und Engraver} interessieren, dann + Kontexte und Engraver sowie die Eigenschaften, die mit ihnen + verknüpft sind, sind die Voraussetzung, um die Funktionsweise + von Optimierungen verstehen zu können. + + + @node Objekte und Schnittstellen + @subsection Objekte und Schnittstellen + @translationof Objects and interfaces + + @cindex Objekte + @cindex Grobs + @cindex Spanners + @cindex Interfaces + @cindex Strecker + @cindex Schnittstellen + @cindex graphische Objekte (Grob) + @cindex Objekteigenschaften + @cindex Layout-Objekt + @cindex Objekt, Layout- + @cindex Eigenschaften von Objekten + + Optimierung bedeutet, die internen Operationen und Strukturen + des LilyPond-Programmes zu verändern, darum sollen hier + zunächst die wichtigesten Begriffe erklärt werden, die zur + Beschreibung dieser Operationen und Strukturen benutzt werden. + + Der Begriff @qq{Objekt} ist ein allgemeiner Begriff, mit dem + die Vielzahl an internen Strukturen bezeichnet wird, die LilyPond + während der Bearbeitung des Quelltextes erstellt. Wenn etwa + ein Befehl wie @code{\new Staff} auftritt, wird ein neues Objekt + vom Typ @code{Staff} erstellt. Dieses Objekt @code{Staff} enthält + dann alle Eigenschaften, die mit diesem speziellen Notensystem + verknüpft sind, wie beispielsweise seine Bezeichnung, Tonart und + spezifische Angaben über die Engraver, die innerhalb dieses Systems + eingesetzt werden. Für alle anderen Kontexte gibt es genauso + Objekte, die deren Eigenschaften beinhalten, beispielsweise für + @code{Voice}-Objekte, @code{Score}-Objekte, @code{Lyrics}-Objekte, + aber auch für Objekte, die Notationselemente wie die Taktlinien, + Notenköpfe, Bögen und Dynamikbezeichnung enthalten. Jedes + Objekt hat eine eigene Gruppe an Eigenschaftswerten. + + Bestimmte Objekttypen tragen besondere Bezeichnungen. Objekte, die + Notationselemente der gesetzten Ausgabe repräsentieren, also + Notenköpfe, Hälse, Bögen, Fingersatz, Schlüssel usw., werden + @qq{Layout-Objekte}, oft auch @qq{Graphische Objekte} genannt. + Daraus resultiert die künstliche Abkürzung @qq{Grob}. + Diese sind auch Objekte im allgemeinen Sinn und haben genauso + Eigenschaften, die mit ihnen verknüpft sind, wie etwa Größe, Position, + Farbe usw. + + Einige Layout-Objekte sind etwas spezieller. Phrasierungsbögen, + Crescendo-Klammern, Oktavierungszeichen und viele andere + Grobs sind nicht an einer Stelle plaziert -- sie haben vielmehr + einen Anfangspunkt, einen Endpunkt und eventuell noch andere + Eigenschaften, die ihre Form bestimmen. Objekte mit solch + einer erweiterten Gestalt werden als @qq{Strecker} (engl. Spanners) + bezeichnet. + + Es bleibt uns noch übrig zu erklären, was @qq{Schnittstellen} + (engl. interface) sind. Wenn auch viele Objekte sehr unterschiedlich + sind, haben sie doch oft gemeinsame Eigenschaften, die auf + die gleiche Weise verarbeitet werden. Alle Grobs beispielsweise + haben eine Farbe, eine Größe, eine Position usw. und alle + diese Eigenschaften werden von LilyPond auf die gleiche Weise + verarbeitet, während der Quelltext in Notensatz umgesetzt wird. + Um die internen Operationen zu vereinfachen, sind alle diese + gemeinsamen Prozesse und Eigenschaften in einem Objekt + mit der Bezeichnung @code{grob-interface} (Schnittstelle eines + graphischen Objektes) zusammengefasst. Es gibt viele andere + Gruppen gemeinsamer Eigenschaften, die jede eine Bezeichnung + besitzen, welche auf @code{-interface} endet. Insgesamt + gibt es über 100 dieser Schnittstellen. Wir werden später sehen, + was es damit auf sich hat. + + Dies waren die Hauptbegriffe, die in diesem Kapitel zur Anwendung + kommen sollen. + + + @node Regeln zur Benennung von Objekten und Eigenschaften + @subsection Regeln zur Benennung von Objekten und Eigenschaften + @translationof Naming conventions of objects and properties + + @cindex Benennungskonventionen für Objekte + @cindex Benennungskonventionen für Eigenschaften + @cindex Objekte, Benennungskonventionen + @cindex Eigenschaften, Benennungskonventionen + @cindex Regeln zur Benennung von Objekten/Eigenschaften + + Es wurden schon früher einige Regeln zur Benennung von + Objekten vorgestellt, siehe + @ref{Kontexte und Engraver}. Hier eine Referenzliste der + häufigsten Objekt- und Eigenschaftsbezeichnungen mit + den Regeln für ihre Bezeichnung und + illustrierenden echten Bezeichnungen. Es wurde @qq{A} + für einen beliebigen Großbuchstaben und @qq{aaa} für eine + beliebige Anzahl an Kleinbuchstaben eingesetzt. Andere + Zeichen werden explizit angegeben. + + @multitable @columnfractions .33 .33 .33 + @headitem Objekt-/Eigenschaftstyp + @tab Naming convention + @tab Beispiele + @item Kontexte + @tab Aaaa oder AaaaAaaaAaaa + @tab Staff, GrandStaff + @item Layout-Objekte + @tab Aaaa oder AaaaAaaaAaaa + @tab Slur, NoteHead + @item Engraver + @tab Aaaa_aaa_engraver + @tab Clef_engraver, Note_heads_engraver + @item Schnittstellen + @tab aaa-aaa-interface + @tab grob-interface, break-aligned-interface + @item Kontext-Eigenschaften + @tab aaa oder aaaAaaaAaaa + @tab alignAboveContext, skipBars + @item Layout-Objekt-Eigenschaften + @tab aaa oder aaa-aaa-aaa + @tab direction, beam-thickness + @end multitable + + Es wird bald ersichtlich werden, dass die Eigenschaften von + unterschiedlichen Objekttypen mit unterschiedlichen Befehlen + geändert werden. Deshalb ist es nützlich, aus der + Schreibweise zu erkennen, um was + für ein Objekt es sich handelt, um den entsprechenden + Befehl einsetzen zu können. + + + @node Optimierungsmethoden + @subsection Optimierungsmethoden + @translationof Tweaking methods + + @cindex override-Befehl + @funindex \override + @funindex override + + @strong{Der \override-Befehl} + + Wir haben uns schon mit den Befehlen @code{\set} + und @code{\with} bekannt gemacht, mit welchen + Eigenschaften von @strong{Kontexten} verändert + und @strong{Engraver} entfernt oder hinzugefügt + werden können. Siehe dazu + @ref{Kontexteigenschaften verändern} und @ref{Engraver hinzufügen und entfernen}. Jetzt wollen wir uns weitere + wichtige Befehle anschauen. + + Der Befehl, um die Eigenschaften von @strong{Layout-Objekten} + zu ändern, ist @code{\override}. Weil dieser Befehl interne + Eigenschaften tief in der Programmstruktur von LilyPond + verändern muss, ist seine Syntax nicht so einfach wie die der + bisherigen Befehle. Man muss genau wissen, welche Eigenschaft + welches Objektes in welchem Kontext geändert werder soll, + und welches der neu zu setzende Wert dann ist. Schauen wir + uns an, wie das vor sich geht. + + Die allgemeine Syntax dieses Befehles ist: + + @example + \override @var{Kontext}.@var{LayoutObjekt} #'@var{layout-eigenschaft} = + #@var{Wert} + @end example + + @noindent + Damit wir die Eigenschaft mit der Bezeichnung @var{layout-property} + das Layout-Objektes mit der Bezeichnung@var{LayoutObject}, + welches ein Mitglied des @var{Kontext}-Kontextes ist, auf den + Wert @var{value}. + + Der @var{Kontext} kann (und wird auch normalerweise) ausgelassen + werden, wenn der benötigte Kontext eindeutig impliziert ist und einer + der untersten Kontexte ist, also etwa @code{Voice}, @code{ChordNames} + oder @code{Lyrics}. Auch in diesem Text wird der Kontext oft ausgelassen + werden. Später soll gezeigt werden, in welchen Fällen er ausdrücklich + definiert werden muss. + + Spätere Abschnitte behandeln umfassend Eigenschaften und ihre + Werte, aber um ihre Funktion und ihr Format zu demonstrieren, + werden wir hier nur einige einfache Eigenschaften und Werte einsetzen, + die einfach zu verstehen sind. + + Für den Moment könne Sie die @code{#'}-Zeichen ignorieren, die vor jeder + Layout-Eigenschaft, und die @code{#}-Zeichen, die vor jedem Wert + stehen. Sie müssen immer in genau dieser Form geschrieben werden. + Das ist der am häufigsten gebrauchte Befehl für die Optimierung, + und der größte Teil dieses Abschnittes wird dazu benutzt, seine Benutzung + zu erläutern. Hier ein einfaches Beispiel, um die Farbe des Notenkopfes + zu ändern: + + @cindex color-Eigenschaft, Beispiel + @cindex Farb-Eigenschaft, Beispiel + @cindex NoteHead, Beispiel für override + @cindex Notenkopf, Beispiel für Veränderung + + @lilypond[quote,fragment,ragged-right,verbatim,relative=1] + c d + \override NoteHead #'color = #red + e f g + \override NoteHead #'color = #green + a b c + @end lilypond + + + @strong{Der \revert-Befehl} + + @cindex revert-Befehl + @funindex \revert + @funindex revert + + Wenn eine Eigenschaft einmal überschrieben wurde, wird ihr + neuer Wert so lange bewahrt, bis er noch einmal überschrieben + wird oder ein @code{\revert}-Befehl vorkommt. Der + @code{\revert}-Befehl hat die folgende Syntax und setzt den + Wert der Eigenschaft zurück auf den Standardwert, nicht + jedoch auf den vorigen Wert, wenn mehrere + @code{\override}-Befehle benutzt wurden. + + @example + \revert @var{Kontext}.@var{LayoutObjekt} #'@var{layout-eigenschaft} + @end example + + Wiederum, genauso wie der @var{Kontext} bei dem @code{\override}-Befehl, + wird @var{Kontext} oft nicht benötigt. Er wird in vielen der folgenden + Beispiele ausgelassen. Im nächsten Beispiel wird die Farbe des Notenkopfes + wieder auf den Standardwert für die letzten zwei Noten gesetzt. + + @cindex color-Eigenschaft, Beispiel + @cindex Farb-Eigenschaft, Beispiel + @cindex NoteHead, Beispiel für override + @cindex Notenkopf, Beispiel für Veränderung + + @lilypond[quote,fragment,ragged-right,verbatim,relative=1] + c d + \override NoteHead #'color = #red + e f g + \override NoteHead #'color = #green + a + \revert NoteHead #'color + b c + @end lilypond + + @strong{\once-Präfix} + + @funindex \once + @funindex once + + Sowohl der @code{\override}-Befehl als auch der @code{\set}-Befehl können mit + dem Präfix @code{\once} (@emph{einmal}) versehen werden. Dadurch wird + der folgende @code{\override}- oder @code{\set}-Befehl nur für den aktuellen + Musik-Moment wirksam, bevor sich wieder der Standard einstellt. Am gleichen + Beispiel demonstriert, kann damit die Farbe eines einzelnen Notenkopfes + geändert werden: + + @cindex color-Eigenschaft, Beispiel + @cindex Farb-Eigenschaft, Beispiel + @cindex NoteHead, Beispiel für override + @cindex Notenkopf, Beispiel für Veränderung + + @lilypond[quote,fragment,ragged-right,verbatim,relative=1] + c d + \once \override NoteHead #'color = #red + e f g + \once \override NoteHead #'color = #green + a b c + @end lilypond + + + @strong{Der \overrideProperty-Befehl} + + @cindex overrideProperty-Befehl + + @funindex \overrideProperty + @funindex overrideProperty + + Es gibt eine andere Form des @code{override}-Befehls, + @code{\overrideProperty} (überschreibe Eigenschaft), + welcher ab und zu benötigt wird. Es wird hier nur der + Vollständigkeit halber erwähnt, sein Einsatz wird demonstriert + in @ruser{Schwierige Korrekturen}. + @c Maybe explain in a later iteration -td + + + @strong{Der \tweak-Befehl} + + @cindex tweak-Befehl + @funindex \tweak + @funindex tweak + + Der letzte Optimierungsbefehl in LilyPond ist @code{\tweak} + (engl. optimieren). Er wird eingesetzt um Eigenschaften + von Objekten zu verändern, die zum selben Musik-Moment + auftreten, wie etwa die Noten eines Akkordes. Ein + @code{\override} würde alle Noten des Akkords beeinflussen, + während mit @code{\tweak} nur das nächste Objekt der + Eingabe geändert wird. + + Hier ein Beispiel. Angenommen, die Größe des mittleren + Notenkopfes (ein E) in einem C-Dur-Akkord soll geändert + werden. Schauen wir zuerst, was wir mit + @code{\once \override} erhalten: + + @cindex Schriftgröße, Beispiel + @cindex NoteHead, Beispiel für override + @cindex Notenkopf, Beispiel für Veränderung + + @lilypond[quote,fragment,ragged-right,verbatim,relative=1] + 4 + \once \override NoteHead #'font-size = #-3 + + + @end lilypond + + Wie man sehen kann, beeinflusst @code{override} @emph{alle} + Notenköpfe des Akkordes. Das liegt daran, dass alle die Noten + eines Akkordes zum selben Musik-Moment auftreten und + die Funktion von @code{\once} ist es, die Optimierung auf + an allen Objekten auszuführen, die zum selben Musik-Moment + auftreten wie der @code{\override}-Befehl. + + Der @code{\tweak}-Befehl funktioniert anders. Er bezieht sich + auf das direkt folgende Element in der Eingabe-Datei. Es wirkt + aber auch nur mit Objekten, die direkt von der Eingabe kreirt + werden, insbesondere Notenköpfe und Artikulationszeichen. + Objekte wie etwa Hälse oder Versetzungszeichen werden erst + später erstellt und lassen sich nicht auf diese Weise ändern. + Zusätzlich @emph{müssen} sich etwa Notenköpfe innerhalb + eines Akkordes befinden, d. h. sie müssen von einfachen spitzen + Klammern umschlossen sein. Um also eine einzelne Note + mit @code{\tweak} zu verändern, muss der Befehl innerhalb + der spitzen Klammern zusammen mit der Note eingegeben werden. + + Um also zu unserem Beispiel zurückzukommen, könnte man die + mittlere Note eines Akkordes auf diese Weise ändern: + + @cindex font-size-Eigenschaft, Beispiel + @cindex Schriftgröße, Beispiel + @cindex @code{\tweak}-Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=1] + 4 + 4 + @end lilypond + + Beachten Sie, dass die Syntax des @code{\tweak}-Befehls sich + von der des @code{\override}-Befehls unterscheidet. Weder + Kontext noch Layout-Objekt konnen angegeben werden, denn + das würde zu einem Fehler führen. Beide Angaben sind + durch das folgende Element impliziert. Hier sollte auch + kein Gleichheitzeichen vorhanden sein. Die verallgemeinerte + Syntax des @code{\tweak}-Befehls ist also einfach + + @example + \tweak #'@var{layout-eigenschaft} #@var{Wert} + @end example + + Ein @code{\tweak}-Befehl kann auch benutzt werden, um nur + eine von mehreren Artikulationen zu ändern, wie im nächsten + Beispiel zu sehen ist. + + @cindex Farb-Eigenschaft, Beispiel + @cindex @code{\tweak}-Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + a ^Black + -\tweak #'color #red ^Red + -\tweak #'color #green _Green + @end lilypond + + @noindent + Beachten Sie, dass dem @code{\tweak}-Befehl ein Artikulationsmodifikartor + vorangestellt werden muss, ganz als ob er selbst ein Artikulationszeichen + wäre. + + @cindex Triolen, geschachtelt + @cindex N-tolen, geschachtelt + @cindex Klammer, Triole + @cindex Triolenklammer + @cindex N-tolenklammer + @cindex Komplizierte Rhythmen, Schachtelung von + @funindex TupletBracket + + Der @code{\tweak}-Befehl muss auch benutzt werden, wenn das + Aussehen einer vor mehreren geschachtelten Triolenklammern + geändert werden soll, die zum selben Zeitpunkt beginnen. + Im folgenden Beispiel beginnen die lange Klammer und die + erste Triolenklammer zum selben Zeitpunkt, sodass ein + @code{\override}-Befehl sich auf beide beziehen würde. + In dem Beispiel wird @code{\tweak} benutzt, um zwischen + ihnen zu unterscheiden. Der erste @code{\tweak}Befehl + gibt an, dass die lange Klammer über den Noten gesetzt + werden soll, und der zweite, dass die Zahl der rhythmischen + Aufteilung für die erste der kurzen Klammern in rot + gesetzt wird. + + @cindex Farb-Eigenschaft, Beispiel + @cindex @code{\tweak}-Beispiel + @cindex Richtungs-Eigenschaft, Beispiel + @cindex color-Eigenschaft, Beispiel + @cindex direction-Eigenschaft, Beispiel + + @lilypond[quote,ragged-right,verbatim,fragment,relative=2] + \tweak #'direction #up + \times 4/3 { + \tweak #'color #red + \times 2/3 { c8[ c8 c8] } + \times 2/3 { c8[ c8 c8] } + \times 2/3 { c8[ c8 c8] } + } + @end lilypond + + Wenn geschachtelte N-tolen nicht zum gleichen Zeitpunkt + beginnen, kann ihr Aussehen auf die übliche Art mit dem + @code{\override}-Befehl geändert werden: + + @cindex text-Eigenschaft, Beispiel + @cindex tuplet-number-Funktion, Beispiel + @cindex transparent-Eigenschaft, Beispiel + @cindex TupletNumber, Beispiel zur Veränderung + @cindex Triolennummer, Beispiel zur Veränderung + @cindex Triolen-Nummer-Funktion, Beispiel + + @c NOTE Tuplet brackets collide if notes are high on staff + @c See issue 509 + @lilypond[quote,ragged-right,verbatim,fragment,relative=1] + \times 2/3 { c8[ c c]} + \once \override TupletNumber + #'text = #tuplet-number::calc-fraction-text + \times 2/3 { + c[ c] + c[ c] + \once \override TupletNumber #'transparent = ##t + \times 2/3 { c8[ c c] } + \times 2/3 { c8[ c c]} + } + @end lilypond + + + @seealso + Notationsreferenz: + @ruser{Der tweak-Befehl}. + + + @node Die Referenz der Programminterna + @section Die Referenz der Programminterna + @translationof The Internals Reference manual + + @menu + * Eigenschaften von Layoutobjekten:: + * Eigenschaften, die Schnittstellen besitzen können:: + * Typen von Eigenschaften:: + @end menu + + @node Eigenschaften von Layoutobjekten + @subsection Eigenschaften von Layoutobjekten + @translationof Properties of layout objects + + @cindex Eigenschaften von Layout-Objekten + @cindex Eigenschaften von Grobs + @cindex Grobs, Eigenschaften von + @cindex Layout-Objekte, Eigenschaften von + @cindex Property (Layout-Objekte, Grobs) + @cindex Regerenz der Interna + + Angenommen, in Ihrer Partitur tritt ein Legatobogen + auf, der Ihrer Meinung nach zu dünn ausgefallen ist. + Sie würden ihn gerne etwas schwerer gezeichnet + sehen. Wie gehen Sie vor? Von den Anmerkungen in + früheren Abschnitten wissen Sie schon, dass LilyPond + sehr flexibel ist und eine derartige Modifikation + möglich sein sollte, und Sie erraten vielleicht, + dass ein @code{\override}-Befehl angebracht ist. + Aber gibt es eine Eigenschaft für die Dicke eines + Legatobogens (engl. slur), und wenn es sie gibt, + auf welche Weise lässt sie sich verändern? Hier + kommt die Referenz der Interna zur Geltung. Dort + finden sich alle Informationen, um den beschriebenen + und alle anderen @code{\override}-Befehle zu + konstruieren. + + Bevor Sie jetzt in die Referenz der Interna wechseln, ist + eine Warnung angebracht. Es handelt sich um ein + @strong{Referenz}dokument, was heißt, dass es sehr + wenig oder gar keine Erklärungen enthält: seine Aufgabe + ist es, Information klar und genau darzustellen. Das + bedeutet, dass es auf den ersten Blick entmutigend + wirkt. Die Einführung und Erklärung in diesem Abschnitt + wird Ihnen aber schnell ermöglichen, genau die Information + aus der Referenz zu entnehmen, die Sie benötigen. + @c For German users + Beachten Sie, dass die Referenz der Interna nur auf Englisch + existiert. Um die Eigenschaftsbezeichnung eines bestimmten + Objektes zu finden, können Sie das Glossar (siehe + @rglosnamed{Top,Musikglossar}) + verwenden, in dem + die englischen Begriffe in viele andere Sprachen übersetzt sind. + + @cindex Override-Beispiel + @cindex Referenz der Interna, Benutzung + @cindex IR (Referenz der Interna), Benutzung + @cindex @code{\addlyrics}-Beispiel + + Das Vorgehen soll an einem konkreten Beispiel einer echten + Komposition demonstriert werden. Hier das Beispiel: + + @lilypond[quote,verbatim,relative=2] + { + \time 6/8 + { + r4 b8 b[( g]) g | + g[( e]) e d[( f]) a | + a g + } + \addlyrics { + The man who feels love's sweet e -- mo -- tion + } + } + @end lilypond + + Angenommen also, wir wollen die Legatobögen etwas + dicker setzten. Ist das möglich? Die Legatobögen sind mit + Sicherheit ein Layout-Objekt, die Frage muss also lauten: + @qq{Gibt es eine Eigenschaft von Legatobögen, die die + Dicke bestimmt?} Um diese Frage zu beantworten, müssen + wir in der Referenz der Interna ( kurz IR) nachschauen. + + Die IR für die LilyPond-Version, die Sie benutzen, findet sich + auf der LilyPond-Webseite unter der Adresse + @uref{http://lilypond.org}. Gehen Sie zur Dokumentationsseite + und klicken Sie auf den Link zur Referenz der Interna. + @c Addition for German users + Die Sprache ändert sich ab hier nach englisch. Für diese Übung + sollten Sie die HTML-Version benutzen, nicht die + @qq{auf einer großen Seite} oder die PDF-Version. + Damit Sie die nächsten Absätze verstehen können, müssen Sie + genauso vorgehen, während Sie weiterlesen. + + Unter der Überschrift @strong{Top} befinden sich fünf Links. + Wählen Sie den Link zum @emph{Backend}, wo sich die Information + über Layout-Objekte befindet. Hier, unter der Überschrift + @strong{Backend}, wählen Sie den Link @emph{All layout objects}. + Die Seite, die sich öffnet, enthält ein Liste aller Layout-Objekte, + die in Ihrerer LilyPond-Version benutzt werden, in alphabetischer + Ordnung. Wählen Sie den Link @emph{Slur} und die Eigenschaften + der Legatobögen (engl. slur) werden aufgelistet. + + Eine alternative Methode, auf diese Seite zu gelangen, ist von + der Notationsreferenz aus. Auf einer der Seiten zu Legatobögen + findet sich ein Link zur Referenz der Interna. Dieser Link führt + Sie direkt auf diese Seite. Wenn Sie aber eine Ahnung haben, + wie die Bezeichnung des Layout-Objektes lauten könnte, das sie + ändern wollen, ist es oft schneller, direkt zur IR zu gehen und + dort nachzuschlagen. + + Aus der Slur-Seite in der IR könne wir entnehmen, dass + Legatobögen (Slur-Objekte) durch den Slur_engraver erstellt + werden. Dann werden die Standardeinstellungen aufgelistet. + Beachten Sie, dass diese @strong{nicht} in alphabetischer Reihenfolge + geordnet sind. Schauen Sie sich die Liste an, ob sie eine Eigenschaft + enthält, mit der die Dicke von Legatobögen kontrolliert werden kann. + Sie sollten folgendes finden: + + @example + @code{thickness} (number) + @code{1.2} + Line thickness, generally measured in @code{line-thickness} + @end example + + Das sieht ganz danach aus, als ob damit die Dicke geändert + werden kann. Es bedeutet, dass der Wert von + @code{thickness} einfach eine Zahl (@emph{number}) ist, + dass der Standardwert 1.2 ist, und dass die Einheit + für die Dicke eine andere Eigenschaft mit der + Bezeichnung @code{line-thickness} ist. + + Wie schon früher gesagt, gibt es wenig bis gar keine Erklärungen + in der IR, aber wir haben schon genug Informationen, um + zu versuchen, die Dicke eines Legatobogens zu ändern. Die + Bezeichnung des Layout-Objekts ist offensichtlich + @code{Slur} und die Bezeichnung der Eigenschaft, die geändert + werden soll + @code{thickness}. Der neue Wert sollte etwas mehr als 1.2 sein, + denn der Bogen soll ja dicker werden. + + Den benötigten @code{\override}-Befehl können wir jetzt einfach + konstruieren, indem wir die Werte für die Bezeichnungen in den + Modellbefehl einfügen und den Kontext auslassen. Setzen wir + einmal einen sehr großen Wert für die Dicke um zu sehen, ob der + Befehl auch funktioniert. Also: + + @example + \override Slur #'thickness = #5.0 + @end example + + Vergessen Sie nicht das Rautenzeichen und Apostroph + (@code{#'}) vor der Eigenschaftsbezeichnung und das + Rautenzeichen vor dem neuen Wert! + + Die nächste Frage ist nun: @qq{Wohin soll dieser Befehl geschrieben + werden?} Solange wir uns noch im Lernstadium befinden, ist + die beste Antwort: @qq{Innerhalb der Noten, vor den ersten + Legatobogen und nahe bei ihm.} Also etwa so: + + @cindex Legatobogen, Beispiel für Veränderung + @cindex thickness-Eigenschaft, Beispiel + @cindex Dicke-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,relative=2] + { + \time 6/8 + { + % Increase thickness of all following slurs from 1.2 to 5.0 + \override Slur #'thickness = #5.0 + r4 b8 b[( g]) g | + g[( e]) e d[( f]) a | + a g + } + \addlyrics { + The man who feels love's sweet e -- mo -- tion + } + } + @end lilypond + + @noindent + und wirklich wird der Legatobogen dicker. + + Das ist also die grundlegende Herangehensweise, + @code{\override}-Befehl zu formulieren. Es gibt einige + zusätzliche Komplikationen, denen wir uns später widmen + werden, aber Sie haben jetzt das Handwerkszeug, um Ihre + eigenen Befehle zu konstruieren -- wenn Sie auch noch etwas + Übung benötigen. Die sollen Sie durch die folgenden Übungen + erhalten. + + + @subheading Den Kontext finden + + @cindex Kontext, Finden und identifizieren + + Manchmal muss dennoch der Kontext spezifiziert werden. + Welcher aber ist der richtige Kontext? Wir könnten raten, + dass Legatobögen sich im @code{Voice}-Kontext befinden, + denn sie sind immer einzelnen Melodielinien zugewiesen. + Aber wir können uns dessen nicht sicher sein. Um unsere + Annahme zu überprüfen, gehen wir wieder zu der Seite im + IR, die die Legatobögen beschreibt und die Überschrift + @emph{Slur} hat. Dort steht: @qq{Slur objects are created + by: Slur engraver}. Legatobögen werden also in dem Kontext + erstellt, in dem sich der @code{Slur_engraver} befindet. + Folgen Sie dem Link zu der @code{Slur_engraver}-Seite. + Unten auf der Seite steht, dass der @code{Slur_engraver} + sich in fünf Stimmen-Kontexten befindet, unter anderem + auch im normalen @code{Voice}-Kontext. Unsere Annahme + war also richtig. Und weil @code{Voice} einer der Kontexte + der untersten Ebene ist, welcher eindeutig schon dadurch + definiert ist, dass wir Noten eingeben, kann er an dieser Stelle + auch weggelassen werden. + + + @subheading Nur einmal mit \override verändern + + @cindex Override nur einmal + @cindex once override + @funindex \once + @funindex once + + Im Beispiel oben wurden @emph{alle} Legatobögen dicker + gesetzt. Vielleicht wollen Sie aber nur den ersten Bogen + dicker haben. Das können Sie mit dem @code{\once}-Befehl + erreichen. Er wird direkt vor den @code{\override}-Befehl + gesetzt und bewirkt, dass nur der Bogen geändert wird, der + @strong{unmittelbar an der nächsten Note beginnt.} Wenn + die nächste Note keinen Bogenbeginn hat, dann passiert + gar nichts -- der Befehl wird nicht gespeichert, sondern einfach + vergessen. Der Befehl, mit @code{\once} zusammen benutzt, + muss also wie folgt positioniert werden: + + @cindex Legatobogen, Beispiel zur Veränderung + @cindex thickness-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,relative=2] + { + \time 6/8 + { + r4 b8 + % Increase thickness of immediately following slur only + \once \override Slur #'thickness = #5.0 + b[( g]) g | + g[( e]) e d[( f]) a | + a g + } + \addlyrics { + The man who feels love's sweet e -- mo -- tion + } + } + @end lilypond + + @noindent + Jetzt bezieht er sich nur noch auf den ersten Legatobogen. + + Der @code{\once}-Befehl kann übrigens auch vor einem @code{\set}-Befehl + eingesetzt werden. + + + @subheading Rückgängig machen + + @cindex Revert + @cindex Rückgängig machen + @cindex Wiederherstellen von Standardeinstellungen + @cindex Standardeinstellungen, Wiederherstellen + @funindex \revert + @funindex revert + + Eine weitere Möglichkeit: nur die beiden ersten Legatobögen sollen + dicker gesetzt werden. Gut, wir könnten jetzt zwei Befehle benutzen, + jeden mit dem @code{\once}-Präfix und direkt vor die entsprechende + Note gestellt, an welcher der Bogen beginnt: + + @cindex Legatobogen, Beispiel zur Veränderung + @cindex thickness-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,relative=2] + { + \time 6/8 + { + r4 b8 + % Increase thickness of immediately following slur only + \once \override Slur #'thickness = #5.0 + b[( g]) g | + % Increase thickness of immediately following slur only + \once \override Slur #'thickness = #5.0 + g[( e]) e d[( f]) a | + a g + } + \addlyrics { + The man who feels love's sweet e -- mo -- tion + } + } + @end lilypond + + @noindent + Wir könnten aber auch den @code{\once}-Befehl weglassen und anstelle + dessen später den @code{\revert}-Befehl einsetzen, um die + @code{thickness}-Eigenschaft wieder auf ihren Standardwert zurückzusetzen: + + @cindex Legatobogen, Beispiel zur Veränderung + @cindex thickness-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,relative=2] + { + \time 6/8 + { + r4 b8 + % Increase thickness of all following slurs from 1.2 to 5.0 + \override Slur #'thickness = #5.0 + b[( g]) g | + g[( e]) + % Revert thickness of all following slurs to default of 1.2 + \revert Slur #'thickness + e d[( f]) a | + a g + } + \addlyrics { + The man who feels love's sweet e -- mo -- tion + } + } + @end lilypond + + @noindent + Der @code{\revert}-Befehl kann benutzt werden, um eine beliebige + Eigenschaft, die mit @code{\override} geändert worden ist, wieder in + ihre Standardeinstellungen zurückzuversetzen. In unserem Beispiel können + Sie die Methode benutzen, die Ihnen lieber ist, beide haben das gleiche + Resultat. + + Damit endet die Einleitung in die Referenz der Interna (IR) und die + grundlegenden Optimierungsmethoden. Einige Beispiele folgen in späteren + Abschnitten dieses Kapitel, einerseits um Sie mit weiteren Möglichkeiten + der IR bekanntzumachen, andererseits um Ihnen mehr Übungsmöglichkeiten + zu geben, die relevante Information dort zu finden. Die Beispiele werden + Schritt für Schritt immer weniger Erklärungen beinhalten. + + + @node Eigenschaften, die Schnittstellen besitzen können + @subsection Eigenschaften, die Schnittstellen besitzen können + @translationof Properties found in interfaces + + @cindex Interface-Eigenschaften + @cindex Eigenschaften von Interfaces + @cindex Schnittstellen, Eigenschaften von + @cindex Eigenschaften von Schnittstellen + + Der Text unseres Beispiels soll jetzt kursiv gesetzt werden. Was für + ein @code{\override}-Befehl wird dazu benötigt? Schauen wir + uns zunächst das Inhaltsverzeichnis in der IR an: @qq{All layout objects}, + wie auch schon zuvor. Welches Objekt könnte die Darstellung des + Textes (engl. lyrics) beeinflussen? Es gibt den Eintrag @code{LyricText}, + das hört sich schon sehr gut an. Ein Klick hierauf zeigt alle Eigenschaften + an, die verändert werden können. Dazu gehört + @code{font-series} und @code{font-size}, aber nichts, womit man kursiven + Text erreichen könnte. Das liegt daran, dass die Schnitteigenschaft allen + Schrift-Objekten gemeinsam ist. Sie findet sich also nicht in jedem einzlenen + Layout-Objekt aufgelistet, sondern ist mit anderen ähnlichen Eigenschaften + zusammen in einem @strong{Interface} -- einer Schnittstelle -- verortet; + in diesem Fall das + @code{font-interface}. + + Jetzt müssen wir also lernen, wie wir Eigenschaften von Schnittstellen finden + und wie wir herausfinden, welche Objekte diese Schnittstelleneigenschaften + benutzen. + + Schauen Sie sich noch einmal die Seite in der IR an, die @code{LyricText} + beschreibt. Unten auf der Seite ist eine klickbare Liste (in der HTML-Version + der IR) an Eigenschaften, die von @code{LyricText} unterstützt + werden. Diese Liste enthält sieben Einträge, darunter auch + @code{font-interface}. Ein Klick hierauf bringt uns zu den Eigenschaften, + die mit dieser Schnittstelle verbunden sind, also auch @code{LyricText}. + + Jetzt sehen wir alle die Eigenschaften, die der Benutzer verändern kann, + um die Schriftartendarstellung zu beeinflussen. Dazu gehört nun auch + @code{font-shape(symbol)}, wobei @code{symbol} auf die Werte + @code{upright} (gerade), @code{italics} (kursiv) oder @code{caps} + (Kapitälchen) gesetzt werden kann. + + Sie werden gemerkt haben, dass @code{font-series} und @code{font-size} + hier auch aufgelistet sind. Es stellt sich die Frage, warum diese + allgemeinen Schriftarteigenschaften @code{font-series} und + @code{font-size} sowohl unter der Überschrift + @code{LyricText} als unter dem @code{font-interface} aufgelistet + sind, aber @code{font-shape} befindet sich nur im + @code{font-interface}? Die Antwort ist: Die globalen Einstellungen + von @code{font-series} und @code{font-size} werden geändert, wenn + ein @code{LyricText}-Objekt erstellt wird, aber @code{font-shape} + wird davon nicht beeinflusst. Die zusätzlichen Einträge unter der + Überschrift @code{LyricText} beinhalten dann die Werte der + Standardeinstellungen dieser zwei Eigenschaften, wenn es sich + um ein @code{LyricText}-Objekt handelt. Andere Objekte, + die auch das @code{font-interface} unterstützen, setzen diese + Eigenschaften anders, wenn sie erstellt werden. + + Versuchen wir nun einen @code{\override}-Befehl zu konstruieren, + der den Gesantext kursiv setzt. Das Objekt hat die Bezeichnung + @code{LyricText}, die Eigenschaft ist @code{font-shape} + und der Wert @code{italic}. Wie vorher schon lassen wir den + Kontext aus. + + Am Rande sei angemerkt, dass die Werte der @code{font-shape}-Eigenschaft + mit einem Apostroph (@code{'}) gekennzeichnet werden + müssen, weil es sich um Symbole handelt. Aus dem gleichen + Grund mussten auch für @code{thickness} weiter oben im + Text ein Apostroph gesetzt werden. Symbole sind besondere + Bezeichnungen, die LilyPond intern bekannt sind. Einige + sind Bezeichnungen von Eigenschaften, wie eben @code{thickness} + oder @code{font-shape}. Andere sind besondere Werte, + die an Eigenschaften übergeben werden können, wie + @code{italic}. Im Unterschied hierzu gibt es auch beliebige + Zeichenketten, die immer mit Anführungszeichen, also + als @code{"Zeichenkette"} auftreten. Für weitere + Einzelheiten zu Zeichenketten und Werten, siehe + @ref{Scheme-Übung}. + + Gut, der @code{\override}-Befehl, mit dem der Gesangstext + kursiv gesetzt wird, lautet: + + @example + \override LyricText #'font-shape = #'italic + @end example + + @noindent + und er muss direkt vor den Text gesetzt werden, auf den er sich + bezieht, etwa so: + + @cindex font-shape-Eigenschaft, Beispiel + @cindex LyricText, Beispiel zur Veränderung + @cindex kursiv, Beispiel + @cindex @code{\addlyrics}, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + { + \time 6/8 + { + r4 b8 b[( g]) g | + g[( e]) e d[( f]) a | + a g + } + \addlyrics { + \override LyricText #'font-shape = #'italic + The man who feels love's sweet e -- mo -- tion + } + } + @end lilypond + + @noindent + Jetzt wird der Text kursiv gesetzt. + + + @subheading Den Kontext im Liedtextmodus bestimmen + + + @cindex Kontext im Gesangstextmodus angeben + @cindex Gesangstextmodus, Kontext angeben + + Bei Gesangstexten funktioniert der @code{\override}-Befehl + nicht mehr, wenn Sie den Kontext im oben dargestellten + Format angeben. Eine Silbe wird im Gesangtextmodus + (lyricmode) entweder von einem Leerzeichen, einer + neuen Zeile oder einer Zahl beendet. Alle anderen + Zeichen werden als Teil der Silbe integriert. Aus diesem + Grund muss auch vor der schließenden Klammer + @code{@}} ein Leerzeichen gesetzt oder eine neue + Zeile begonnen werden. Genauso müssen Leerzeichen + vor und nach einem Punkt benutzt werden, um die + Kontext-Bezeichnung von der Objekt-Bezeichnung zu + trennen, denn sonst würden beide Bezeichnungen als + ein Begriff interpretiert und von LilyPond nicht verstanden + werden. Der Befehl muss also lauten: + + @example + \override Lyrics . LyricText #'font-shape = #'italic + @end example + + @warning{Innerhalb von Gesangstext muss immer ein + Leerzeichen zwischen der letzten Silbe und der schließenden + Klammer gesetzt werden.} + + @warning{Innerhalb von @code{\override}-Befehlen in + Gesangstexten müssen Leerzeichen um Punkte zwischen + Kontext- und Objektbezeichnungen gesetzt werden.} + + + @node Typen von Eigenschaften + @subsection Typen von Eigenschaften + @translationof Types of properties + + @cindex Eigenschaftsarten + + Bis jetzt hatten wir es mit zwei Arten von Eigenschaften zu + tun: @code{number} (Zahl) und @code{symbol}. Damit + ein Befehl funktioniert, muss der Wert einer Eigenschaft + vom richtigen Typ sein und die Regeln befolgen, die + für diesen Typ gelten. Der Eigenschaftstyp ist in der + IR in Klammern hinter der Eigenschaftsbezeichnung + angegeben. Hier eine Liste der Typen, die Sie vielleicht + benötigen werden, mit den Regeln, die für den jeweiligen + Typ gelten und einigen Beispielen. Sie müssen immer + ein Rautenzeichen (@code{#}) vor den Typeintrag setzen, + wenn sie in einem @code{\override}-Befehl benutzt werden. + + @multitable @columnfractions .2 .45 .35 + @headitem Eigenschaftstyp + @tab Regeln + @tab Beispiele + @item Boolesch + @tab Entweder wahr oder falsch, dargestellt als #t oder #f + @tab @code{#t}, @code{#f} + @item Dimension (in Notenlinienabständen) + @tab Eine positive Dezimalzahl (in Notenlinienabstand-Einheiten) + @tab @code{2.5}, @code{0.34} + @item Richtung + @tab Eine gültige Richtungskonstante oder das numerische Äquivalent + @tab @code{LEFT}, @code{CENTER}, @code{UP}, + @code{1}, @code{-1} + @item Integer + @tab Eine positive ganze Zahl + @tab @code{3}, @code{1} + @item Liste + @tab Eine eingeklammerte Anzahl von Einträgen, mit Klammern getrennt + und angeführt von einem Apostroph + @tab @code{'(left-edge staff-bar)}, @code{'(1)}, + @code{'(1.0 0.25 0.5)} + @item Textbeschriftung (markup) + @tab Beliebige gültige Beschriftung + @tab @code{\markup @{ \italic "cresc." @}} + @item Moment + @tab Ein Bruch einer ganzen Note, mit der make-moment-Funktion + konstruiert + @tab @code{(ly:make-moment 1 4)}, + @code{(ly:make-moment 3 8)} + @item Zahl + @tab Eine beliebige positive oder negative Dezimalzahl + @tab @code{3.5}, @code{-2.45} + @item Paar (Zahlenpaar) + @tab Zwei Zahlen getrennt von @qq{Leerzeichen . Leerzeichen}, eingeklammert + und angeführt von einem Apostroph + @tab @code{'(2 . 3.5)}, @code{'(0.1 . -3.2)} + @item Symbol + @tab Eine beliebige Anzahl von Symbolen, die für die Eigenschaft + gültig sind, angeführt von einem Apostroph + @tab @code{'italic}, @code{'inside} + @item Unbekannt + @tab Eine Prozedur oder @code{#f} (um keine Aktion hervorzurufen) + @tab @code{bend::print}, @code{ly:text-interface::print}, + @code{#f} + @item Vektor + @tab Eine Liste mit drei Einträgen, eingeklammert und mit + Apostroph-Raute ( @code{'#}) angeführt. + @tab @code{'#(#t #t #f)} + @end multitable + + + @seealso + Handbuch zum Lernen: @ref{Scheme-Übung}. + + + @node Erscheinung von Objekten + @section Erscheinung von Objekten + @translationof Appearance of objects + + In diesem Abschnitt wollen wir zeigen, wie die Kenntnisse der + vorigen Abschnitte in der Praxis angewandt werden können, + um das Aussehen des Musiksatzes zu beeinflussen. + + @menu + * Sichtbarkeit und Farbe von Objekten:: + * Größe von Objekten:: + * Länge und Dicke von Objekten:: + @end menu + + + @node Sichtbarkeit und Farbe von Objekten + @subsection Sichtbarkeit und Farbe von Objekten + @translationof Visibility and color of objects + + In Unterrichtsmaterial für den Musikunterricht wird oft + eine Partitur dargestellt, in der bestimmte Notationselemente + fehlen, so dass der Schüler die Aufgabe bekommt, die + nachzutragen. Ein einfaches Beispiel ist etwa, die + Taktlinien zu entfernen, damit der Schüler sie selber zeichnen + kann. Aber die Tatklinien werden normalerweise automatisch + eingefügt. Wie verhindern wir, dass sie ausgegeben werden? + + Bevor wir uns hieran machen, sei daran erinnert, dass + Objekteigenschaften in sogenannten @emph{Schnittstellen} + -- engl. interface -- gruppiert sind, siehe auch + @ref{Eigenschaften, die Schnittstellen besitzen können}. Das dient ganz einfach + dazu, die Eigenschaften zusammenzufassen, die üblicherweise + zusammen benötigt werden -- wenn eine davon für ein Objekt + gilt, dann auch die anderen. Manche Objekte brauchen die + Eigenschaften von der einen Schnittstelle, andere von einer + anderen. Die Schnittstellen, die die Eigenschaften von einem + bestimmten Grob beinhalten, sind in der IR unten auf der + Seite aufgelistet, die dieses Grob beschreibt. Die Eigenschaften + können betrachtet werden, indem die Seite der entsprechenden + Schnittstelle geöffnet wird. + + Zu Information, wie man Eigenschaften von Grobs findet, siehe + @ref{Eigenschaften von Layoutobjekten}. Wir benutzen also jetzt + die selbe Methode um in der IR das Layout-Objekt zu finden, + dass für die Tatklinien zuständig ist. Über die Überschriften + @emph{Backend} und @emph{All layout objects} kommen + wir zu einem Layout-Objekt mit der Bezeichnung + @code{BarLine} (engl. TaktLinie). Seine Eigenschaften + beinhalten zwei, die über die Sichtbarkeit entscheiden: + @code{break-visibility} und @code{stencil}. + @code{BarLine} unterstützt auch einige Schnittstellen, + unter anderem @code{grob-interface}, wo wir eine + @code{transparent} und eine @code{color}-Eigenschaft + finden. Alle können die Sichtbarkeit von Taktlinien (und + natürlich auch die Sichtbarkeit von vielen anderen Objekten) + beeinflussen. Schauen wir uns diese Eigenschaften eine + nach der anderen an. + + @subheading stencil (Matrize) + + @cindex Stencil-Eigenschaft + @cindex Matrizen-Eigenschaft + + Diese Eigenschaft kontrolliert die Erscheinung der Taktlinien, + indem sie das Symbol bestimmt, das ausgegeben werden soll. + Wie bei vielen anderen Eigenschaften auch, kann sie so + eingestellt werden, dass sie nichts ausgibt, indem ihr Wert + auf @code{#f} (falsch) gesetzt wird. Ein Versuch also, + wie vorher, indem wir den impliziten Kontext (@code{Voice}) + auslassen: + + @cindex Taktlinie, Beispiel zur Veränderung + @cindex stencil-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + { + \time 12/16 + \override BarLine #'stencil = ##f + c4 b8 c d16 c d8 | + g, a16 b8 c d4 e16 | + e8 + } + @end lilypond + + Die Taktlinien werden aber immer noch angezeigt. Was ist da + falsch gelaufen? Gehen Sie zurück zur IR und schauen Sie auf + die Seite, die die Eigenschafter für @code{BarLine} angibt. + Oben auf der Seite steht: @qq{Barline objects are created + by: Bar_engraver}. Schauen Sie sich die + @code{Bar_engraver}-Seite an. Unten auf der Seite steht + eine Liste der Kontexte, in denen der Takt-Engraver + funktioniert. Alle Kontexte sind @code{Staff}-Typen (also + Notensystem-Typen). Der Grund, warum der + @code{\override}-Befehl nicht funktioniert hat, liegt + also darin, dass das Taktlinie-Objekt (@code{BarLine}) sich nicht + im @code{Voice}-Kontextbefindet. Wenn der Kontext + falsch angegeben wird, bewirkt der Befehl einfach gar + nichts. Keine Fehlermeldung wird ausgegeben und auch + nichts in die Log-Datei geschrieben. Versuchen wir also, + den richtigen Kontext mitanzugeben: + + @cindex Taktlinie, Beispiel zur Veränderung + @cindex stencil-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + { + \time 12/16 + \override Staff.BarLine #'stencil = ##f + c4 b8 c d16 c d8 | + g, a16 b8 c d4 e16 | + e8 + } + @end lilypond + + @noindent + Jetzt sind die Taktlinien wirklich verschwunden. + + Es sollte jedoch beachtet werden, dass das Setzen der + @code{stencil}-Eigenschaft auf @code{#f} zu Fehlerhinweisen führen + kann, wenn die Dimensionen des Objekts für die richtige Behandlung + benötigt werden. Zum Beispiel werden Fehler ausgegeben, wenn + die @code{stencil}-Eigenschaft des @code{NoteHead}-Objekts auf -@code{#f} gesetzt wird. ++@code{#f} gesetzt wird. Wenn dieser Fall auftritt, kann anstatt ++dessen die @code{point-stencil}-Funktion benutzt werden, welche ++den Stencil auf ein Objekt mit der Größe Null setzt: ++ ++@lilypond[quote,verbatim,relative=2] ++{ ++ c c ++ \once \override NoteHead #'stencil = #point-stencil ++ c c ++} ++@end lilypond + + + @subheading break-visibility (unsichtbar machen) + + @cindex break-visibility-Eigenschaft + @cindex Unsichtbar machen (break-visibility) + + Aus der Beschreibung der Eigenschaften für @code{BarLine} + in der IR geht hervor, dass die @code{break-visibility}-Eigenschaft + einen Vektor mit drei Booleschen Werten benötigt. Diese + kontrollieren jeweils, ob die Taktlinien am Ende einer Zeile, + in der Mitte einer Zeile und am Anfang einer Zeile ausgegeben + werden. Wenn also alle Taktlinien unsichtbar sein sollen, wie in + unserem Beispiel, brauchen wir den Wert @code{'#(#f #f #f)}. + Versuchen wir es also, und berücksichtigen wir auch den + @code{Staff}-Kontext. Beachten Sie auch, dass Sie @code{#'#} + vor der öffnenden Klammer schreiben müssen: + @code{'#} wird benötigt als Teil des Wertes, um einen Vektor zu + signalisieren, und das erste @code{#} wird benötigt, um + den Wert in einem @code{\override}-Befehl anzuführen. + + @cindex Taktlinie, Beispiel zur Veränderung + @cindex break-visibility-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + { + \time 12/16 + \override Staff.BarLine #'break-visibility = #'#(#f #f #f) + c4 b8 c d16 c d8 | + g, a16 b8 c d4 e16 | + e8 + } + @end lilypond + + @noindent + Auch auf diesem Weg gelingt es, die Taktlinien unsichtbar zu machen. + + + @subheading transparent (durchsichtig) + + @cindex transparent-Eigenschaft + @cindex Durchsichtig machen (transparent) + + Aus den Eigenschaftsdefinitionen auf der @code{grob-interface}-Seite + in der IR geht hervor, dass die @code{transparent}-Eigenschaft + boolesch ist. Mit @code{#t} (wahr) wird also ein Grob durchsichtig + gemacht. Im unserem Beispiel soll jetzt die Taktart durchsichtig + gemacht werden, anstatt die Taktlinien durchsichtig zu machen. + Wir brauchen also wieder die Grob-Bezeichnung für die Taktart. + Auf der @qq{All layout objects}-Seite in der IR müssen wir die + Eigenschaften des @code{TimeSignature}-Layout-Objekts suchen + Das Objekt wird vom @code{Time_signature_engraver} erstellt, + der sich auch im @code{Staff}-Kontext befindet und genauso das + @code{grob-interface} unterstützt, wie Sie sich + überzeugen können. Der Befehl, um die Taktangabe unsichtbar zu + machen, ist also: + + @cindex Taktart, Beispiel zur Veränderung + @cindex transparent-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + { + \time 12/16 + \override Staff.TimeSignature #'transparent = ##t + c4 b8 c d16 c d8 | + g, a16 b8 c d4 e16 | + e8 + } + @end lilypond + + @noindent + Die Taktangabe ist verschwunden, aber mit diesem Befehl wird ein + freier Platz gelassen, wo sich die Taktangabe eigentlich befinden + würde. Das braucht man vielleicht für eine Schulaufgabe, in der + die richtige Taktangabe eingefügt werden soll, aber in anderen + Fällen ist diese Lücke nicht schön. Um auch die Lücke zu entfernen, + muss die Matrize (stencil) der Taktangabe auf @code{#f} (falsch) + gesetzt werden: + + @cindex Taktart, Beispiel zur Veränderung + @cindex stencil-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + { + \time 12/16 + \override Staff.TimeSignature #'stencil = ##f + c4 b8 c d16 c d8 | + g, a16 b8 c d4 e16 | + e8 + } + @end lilypond + + @noindent + Und der Unterschied wird deutlich: hiermit wird das gesamte Objekt + entfernt, während man mit @code{transparent} ein Objekt + unsichtbar machen kann, es aber an seinem Platz gelassen wird. + + + @subheading color (Farbe) + + @cindex color-Eigenschaft + @cindex Farb-Eigenschaft + + Abschließend wollen wir die Taktlinien unsichtbar machen, indem + wir sie weiß einfärben. (Es gibt hier eine Schwierigkeit: die weiße + Taktlinie übermalt manchmal die Taktlinienen, wo sie sie kreuzt, + manchmal aber auch nicht. Sie können in den Beispielen unten + sehen, dass das nicht vorhersagbar ist. Die Einzelheiten dazu, warum + das passiert und wie sie es kontrollieren können, werden dargestellt + in @ruser{Objekte weiß malen}. Im Moment wollen wir lernen, wie + man mit Farbe arbeitet, akzeptieren Sie bitte an dieser Stelle die + Beschränkung.) + + Das @code{grob-interface} bestimmt, dass der Wert der Farb-Eigenschaft + eine Liste ist, aber es gibt keine Erklärung, was für eine Liste das + sein soll. Die Liste, die benötigt wird, ist eine Liste mit Werten in + internen Einheiten, aber damit Sie nicht wissen müssen, wie diese + aussehen, gibt es mehrere Wege, Farben anzugeben. Der erste + Weg ist es, @qq{normale} Farben zu benutzen, wie sie in der + Tabelle in @ruser{Liste der Farben} aufgelistet sind. Beachten Sie, + dass die Bezeichnungen auf English sind. Um die Taktlinien auf + weiß zu setzen, können Sie schreiben: + + @cindex Taktlinie, Beispiel zur Veränderung + @cindex color-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + { + \time 12/16 + \override Staff.BarLine #'color = #white + c4 b8 c d16 c d8 | + g, a16 b8 c d4 e16 | + e8 + } + @end lilypond + + @noindent + und die Taktlinien verschwinden in der Tat. Beachten Sie, + dass @emph{white} nicht mit einem Apostroph angeführt + wird -- es ist kein Symbol, sondern eine @emph{Funktion}. + Wenn sie aufgerufen wird, stellt sie eine Liste mit internen + Werten zu Verfügung, mit welcher die Farbe auf weiß + gestellt wird. Die anderen Farben in der Liste sind auch + Funktionen. Um sich zu überzeugen, dass der Befehl auch + wirklich funktioniert, können Sie die Farbe auf eine der + anderen Funktionen dieser Liste abändern. + + @cindex Farben, X11 + @cindex X11-Farben + @funindex x11-color + + Die zweite Art die Farbe zu ändern geschieht, indem die Liste + der X11-Farbbezeichnungen einzusetzen, siehe die zweite Liste + in @ruser{Liste der Farben}. Diesen Farben muss jedoch eine + andere Funktion vorangestellt werden, die die X11-Farbbezeichnungen + in interne Werte konvertiert: + @code{x11-color}. Das geschieht wie folgt: + + @cindex Taktlinie, Beispiel zur Veränderung + @cindex color-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + { + \time 12/16 + \override Staff.BarLine #'color = #(x11-color 'white) + c4 b8 c d16 c d8 | + g, a16 b8 c d4 e16 | + e8 + } + @end lilypond + + @noindent + In diesem Fall hat die Funktion @code{x11-color} ein Symbol + als Argument, darum muss dem Symbol ein Apostroph vorangestellt + und beide zusammen in Klammern gesetzt werden. + + @cindex RGB-Farben + @cindex Farben, RGB + @funindex rgb-color + + Es gibt noch eine dritte Funktion, die RGB-Werte in die + internen Werte übersetzt -- die @code{rgb-color}-Funktion. Sie + braucht drei Argumente, um die Stärke von Rot, Grün und + Blau darzustellen. Die Werte befinden sich zwischen + 0 und 1. Um also die Farbe Rot darzustellen, muss der + Wert der Funktion lauten: @code{(rgb-color 1 0 0)}, weiß + würde sein: @code{(rgb-color 1 1 1)}. + + @cindex Taktlinie, Beispiel zur Veränderung + @cindex color-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + { + \time 12/16 + \override Staff.BarLine #'color = #(rgb-color 1 1 1) + c4 b8 c d16 c d8 | + g, a16 b8 c d4 e16 | + e8 + } + @end lilypond + + Schließlich gibt es noch eine Grauskala, die zu den X11-Farben + gehört. Sie reicht von schwarz (@code{'grey0'}) bis + weiß (@code{'grey100}), in Einserschritten. Wir wollen das + illustrieren, indem alle Layout-Objekte im Beispiel + verschiede Grauschattierungen erhalten: + + @cindex StaffSymbol, Beispiel zur Veränderung + @cindex TimeSignature, Beispiel zur Veränderung + @cindex Schlüssel, Beispiel zur Veränderung + @cindex Notenhals, Beispiel zur Veränderung + @cindex Taktlinie, Beispiel zur Veränderung + @cindex Farbeigenschaft, Beispiel + @cindex x11-Farben, Beispiel + @cindex Taktlinien, Beispiel zur Veränderung + @cindex Taktart, Beispiel zur Veränderung + @cindex Clef, Beispiel zur Veränderung + @cindex Stem, Beispiel zur Veränderung + @cindex NoteHead, Beispiel zur Veränderung + @cindex Notenkopf, Beispiel zur Veränderung + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + { + \time 12/16 + \override Staff.StaffSymbol #'color = #(x11-color 'grey30) + \override Staff.TimeSignature #'color = #(x11-color 'grey60) + \override Staff.Clef #'color = #(x11-color 'grey60) + \override Voice.NoteHead #'color = #(x11-color 'grey85) + \override Voice.Stem #'color = #(x11-color 'grey85) + \override Staff.BarLine #'color = #(x11-color 'grey10) + c4 b8 c d16 c d8 | + g, a16 b8 c d4 e16 | + e8 + } + @end lilypond + + @noindent + Beachten Sie die Kontexte, die mit jedem einzelnen Layout-Objekt + verbunden sind. Es ist wichtig, den richtigen Kontext einzusetzen, + damit die Befehle funktionieren. Denken Sie daran, dass der + Kontext sich daran orientiert, wo sich der entsprechende + Engraver befindet. Den Standardkontext für Engraver finden + Sie, indem Sie beim Layout-Objekt beginnen, zum Engraver + gehen, der es produziert und auf der Seite des Engravers in der + IR finden Sie Information, in welchem Kontext sich der + Engraver normalerweise befindet. + + + @node Größe von Objekten + @subsection Größe von Objekten + @translationof Size of objects + + @cindex Veränderung von Objektgrößen + @cindex Objektgrößen, verändern + @cindex Größen von Objekten verändern + + Als Startpunkt wollen wir wieder ein früheres Beispiel + wählen, siehe @ref{Musikalische Ausdrücke ineinander verschachteln}. Hier wurde + ein neues Notensystem erstellt, wie man es für ein @rglos{ossia} + braucht. + + @cindex alignAboveContext-Eigenschaft, Beispiel + @cindex über dem System anordnen, Beispiel + @cindex @code{\with}-Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + \new Staff ="main" { + \relative g' { + r4 g8 g c4 c8 d | + e4 r8 + << + { f c c } + \new Staff \with { + alignAboveContext = #"main" } + { f8 f c } + >> + r4 | + } + } + @end lilypond + + Ossia-Systeme werden normalerweise ohne Schlüssel und Taktangabe + geschrieben, und sie werden etwas kleiner als das Hauptsystem gesetzt. + Wie man Schlüssel und Taktangabe entfernt, wissen wir schon: + wir setzen den Stencil von beiden auf @code{#f}: + + @cindex alignAboveContext-Eigenschaft, Beispiel + @cindex über dem System anordnen, Beispiel + @cindex @code{\with}-Beispiel + @cindex stencil-Eigenschaft, Beispiel + @cindex Schlüssel, Beispiel zur Veränderung + @cindex Taktart, Beispiel zur Veränderung + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + \new Staff ="main" { + \relative g' { + r4 g8 g c4 c8 d | + e4 r8 + << + { f c c } + \new Staff \with { + alignAboveContext = #"main" + } + { + \override Staff.Clef #'stencil = ##f + \override Staff.TimeSignature #'stencil = ##f + { f8 f c } + } + >> + r4 | + } + } + @end lilypond + + @noindent + wobei ein zusätzliches Klammerpaar nach der @code{\with}-Konstruktion + erforderlich ist um sicherzugehen, dass die Modifikation und + die Noten sich auch auf das Ossia-System beziehen. + + Was für einen Unterschied macht es, ob man den @code{Staff}-Kontext + mit @code{\with} verändert, oder ob man die Stencils mit + @code{\override} beeinflusst? Der größte Unterschied liegt + darin, dass Änderungen, die mit @code{\with} eingeführt werden, + während der Erstellung des Kontextes miterzeugt werden und + als @strong{Standardeinstellungen} für diesen Kontext während seiner + gesamten Dauer gelten, während @code{\set}- oder @code{\override}-Befehle + dynamisch in die Noten eingebettet werden -- sie führen die + Änderungen synchron mit einem bestimmten Zeitpunkt in + der Musik aus. Wenn die Änderungen mit @code{\unset} + oder @code{\revert} rückgängig gemacht werden, werden + wieder die Standardwerte eingesetzt, die also die sind, die + mit einer @code{\with}-Konstruktion definiert wurden, oder + wenn hier keine definiert worden sind, die normalen + Standardwerte. + + Manche Kontexteigenschaften können nur ein einer + @code{\with}-Konstruktion verändert werden. Das sind + Eigenschaften, die nicht sinnvoll mitten im System geändert + werden können. @code{alignAboveContext} (Orientierung + über dem Kontext) und die Parallele, + @code{alignBelowContext} (Orientierung unter dem Kontext) + sind zwei derartige Eigenschaften -- wenn das Notensystem + einmal erstellt wurde, ist die Orientierung schon bestimmt + und es wäre nicht sinnvoll, sie später zu ändern. + + Die Standardwerte für Layout-Objekt-Eigenschaften können + auch in der @code{\with}-Konstruktion gesetzt werden. + Benutzen Sie einfach den normalen @code{\override}-Befehl + ohne den Kontext, denn der Kontext ist eindeutig definiert + durch die Stelle, an welcher sich @code{\with} befindet. + Wenn an dieser Stelle ein Kontext angegeben wird, produziert LilyPond + eine Fehlermeldung. + + Das obige Beispiel könnte also auch so aussehen: + + @cindex alignAboveContext-Eigenschaft, Beispiel + @cindex über dem System anordnen, Beispiel + @cindex @code{\with}-Beispiel + @cindex stencil-Eigenschaft, Beispiel + @cindex Schlüssel, Beispiel zur Veränderung + @cindex Taktart, Beispiel zur Veränderung + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + \new Staff ="main" { + \relative g' { + r4 g8 g c4 c8 d | + e4 r8 + << + { f c c } + \new Staff \with { + alignAboveContext = #"main" + % Don't print clefs in this staff + \override Clef #'stencil = ##f + % Don't print time signatures in this staff + \override TimeSignature #'stencil = ##f + } + { f8 f c } + >> + r4 | + } + } + @end lilypond + + Nun können wir daran gehen, auch wirklich die + Größe der Objekte zu ändern. + + Manche Layout-Objekte werden aus Glyphen erstellt, + die sich in einer Schriftartdatei befinden. Dazu gehören + die Notenköpfe, Versetzungszeichen, Text, Schlüssel, + Taktbezeichnung, Dynamik und Gesangstext. Ihre + Größe wird verändert, indem die + @code{font-size}- (Schriftgröße)-Eigenschaft geändert wird, wie + wir bald sehen werden. Andere Layout-Objekte, wie + Bögen -- oder allgemein Strecker-Objekte -- werden + individuell gezeichnet, es gibt dazu also keine + @code{font-size}, die mit ihnen verknüpft wäre. + Weitere Eigenschaften wie die Länge von Hälsen und + Taktlinien, Dicke von Balken und anderen Linien und + der Abstand der Notenlinien voneinander müssen auf + spezielle Weise verändert werden. + + In unserem Ossia-Beispiel wollen wir zuerst die + Schriftgröße verändern. Das ist auf zwei Arten möglich. + Entweder wir ändern die Schriftgröße für jede Objektart + mit einem eigenen Befehl, etwa: + + @example + \override NoteHead #'font-size = #-2 + @end example + + @noindent + oder wir ändern die Größe aller Schriftobjekte, indem wir + den Wert einer besonderen Eigenschaft, @code{fontSize}, + mit dem @code{\set}-Befehl bestimmen oder sie in + eine @code{\with}-Konstruktion (ohne @code{\set} einschließen. + + @example + \set fontSize = #-2 + @end example + + Beide Beispiele reduzieren die Schriftgröße um zwei Schritte + im Vergleich zum vorigen Wert, wobei jeder Schritt die + Schriftgröße um etwa 12% verändert. + + Setzen wir das also in unserem Ossia-Beispiel ein: + + @cindex alignAboveContext-Eigenschaft, Beispiel + @cindex über dem System anordnen, Beispiel + @cindex @code{\with}-Beispiel + @cindex stencil-Eigenschaft, Beispiel + @cindex Schlüssel, Beispiel zur Veränderung + @cindex Taktart, Beispiel zur Veränderung + + @lilypond[quote,verbatim,fragment,ragged-right,relative=2] + \new Staff ="main" { + \relative g' { + r4 g8 g c4 c8 d | + e4 r8 + << + { f c c } + \new Staff \with { + alignAboveContext = #"main" + \override Clef #'stencil = ##f + \override TimeSignature #'stencil = ##f + % Reduce all font sizes by ~24% + fontSize = #-2 + } + { f8 f c } + >> + r4 | + } + } + @end lilypond + + Das sieht aber immer noch nicht richtig aus. Die Notenköpfe + und Fähnchen sind kleiner, aber die Hälse im Vergleich + dazu zu lang und die Notenlinien zu weit auseinander. + Sie müssen auch proportional zur Schriftart verkleinert + werden. Der nächste Abschnitt behandelt diese Anpassung. + + + @node Länge und Dicke von Objekten + @subsection Länge und Dicke von Objekten + @translationof Length and thickness of objects + + @cindex Entfernungen + @cindex Dicke + @cindex Länge + @funindex magstep + @cindex Größe, verändern + @cindex Notenhalslänge, verändern + @cindex Hälse, Länge verändern + @cindex Notenlinien, Länge verändern + + Abstände und Längen werden in LilyPond üblicherweise + in Notenlinienabständen (engl. staff-spaces) gemessen. + Das ist der Abstand zwischen zwei Notenlinien im System. + Die meisten Dicken (engl. thickness) dagegen werden in + einer internen Einheit Linien-Dicke (engl. line-thickness) + gemessen. Die Linien von Dynamikklammern zum Beispiel + haben standardmäßig eine Dicke von einer Einheit + @code{line-thickness}, während die Dicke eines + Notenhalses 1,3 ist. Beachten Sie jedoch, dass sich + manche Dicken anders verhalten: die Dicke von + Balken etwa wird in Notenlinienabständen gemessen. + + Wie also werden Längen skaliert um der Schriftgröße + zu entsprechen? Das kann mit einer besonderen Funktion + @code{magstep} vorgenommen werden, die genau für + diesen Zweck vorhanden ist. Sie nimmt ein Argument auf, + die Änderung der Schriftgröße (#-2 im obigen Beispiel) + und gibt einen Skalierungsfaktor aus, der dazu dient, + Objekte proportionell zueinander zu verändern. So wird + sie benutzt: + + @cindex alignAboveContext-Eigenschaft, Beispiel + @cindex über dem System anordnen, Beispiel + @cindex @code{\with}-Beispiel + @cindex stencil-Eigenschaft, Beispiel + @cindex Schlüssel, Beispiel zur Veränderung + @cindex Taktart, Beispiel zur Veränderung + @cindex Notenlinienabstände verändern + @cindex staff-space-Eigenschaft verändern + @cindex magstep-Funktion, Beispiel + @cindex Schriftart-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,fragment,ragged-right,relative=2] + \new Staff ="main" { + \relative g' { + r4 g8 g c4 c8 d | + e4 r8 + << + { f c c } + \new Staff \with { + alignAboveContext = #"main" + \override Clef #'stencil = ##f + \override TimeSignature #'stencil = ##f + fontSize = #-2 + % Reduce stem length and line spacing to match + \override StaffSymbol #'staff-space = #(magstep -2) + } + { f8 f c } + >> + r4 | + } + } + @end lilypond + + @noindent + Da die Länge eines Halses und viele andere Längeneigenschaften + relativ zum Wert des Notenlinienabstands (@code{staff-space}) + errechnet werden, werden sie auch automatisch verkleinert. + Das wirkt sich jedoch nur auf die vertikale Skalierung des Ossias + aus -- die horizontale Skala ist durch das Layout des Haupsystems + bestimmt und wird also von diesen Größenänderungen nicht + betroffen. Wenn natürlich die Größe der gesamten Noten reduziert + würde, würde sich auch die horizontalen Abstände ändern. Dass + wird später im Layout-Abschnitt betrachtet. + + Mit dieser Änderung ist unser Ossia fertig. Die Größen und Längen + aller anderen Objekte können auf analoge Weise geändert + werden. + + Für kleine Größenänderungen, wie in dem obigen Beispiel, + braucht die Dicke der verschiedenen Linien, wie Taktlinien, + Notenlinien, Balken, Dynamikklammern usw. normalerweise + keine spezielle Anpassung. Wenn die Dicke eines bestimmten + Layout-Objektes angepasst werden muss, kann man das erreichen, + indem die entsprechende @code{thickness}-Eigenschaft des + Objekts mit @code{\override} verändert wird. Ein Beispiel, + wie man die Dicke von Bögen ändert, wurde schon gezeigt, + siehe @ref{Eigenschaften von Layoutobjekten}. Die Dicke aller + gezeichneten Objekte (die also nicht aus einer Schriftart + stammen) können auf gleiche Weise geändert werden. + + + @node Positionierung von Objekten + @section Positionierung von Objekten + @translationof Placement of objects + + @menu + * Automatisches Verhalten:: + * within-staff (Objekte innerhalb des Notensystems):: + * Objekte außerhalb des Notensystems:: + @end menu + + + @node Automatisches Verhalten + @subsection Automatisches Verhalten + @translationof Automatic behavior + + @cindex within-staff-Objekte + @cindex outside-staff-Objekte + @cindex Objekte innerhalb des Notensystems + @cindex Objekte außerhalb des Notensystems + + Es gibt Objekte der Notation, die zum Notensystem gehören, und + andere, die außerhalb des Systems gesetzt werden müssen. Sie + werden @code{within-staff}-Objekte bzw. + @code{outside-staff}-Objekte genannt. + + @code{within-staff}-Objekte werden innerhalb des Notensystems + (engl. staff) gesetzt: Notenköpfe, Hälse, Versetzungszeichen + usw. Ihre Position ist üblicherweise durch die notierte Musik + bestimmt -- sie werden vertikal auf bestimmten Linien notiert + oder sind an andere Objekte gebunden, die vertikal festgelegt + sind. Kollisionen von Notenköpfen, Hälsen und Versetzungszeichen + werden normalerweise automatisch vermieden. Es gibt + Befehle, um dieses automatische Verhalten zu verändern, wie + unten gezeigt werden soll. + + Objekte, die außerhalb des Notensystems gesetzt werden, sind + unter Anderem Übungsmarkierungen, Text und Dynamikzeichen. + LilyPonds Regel für ihre vertikale Positionierung lautet, sie so nah wie + möglich am Notensystem zu setzen, aber nicht so nah, dass + sie mit anderen Objekten kollidieren. Dabei wird die + @code{outside-staff-priority}-(Priorität außerhalb des Notensystems)-Eigenschaft + eingesetzt, um die Reihenfolge zu bestimmen, in denen Objekte gesetzt werden + sollen. + + Zuerst werden alle Innersystemobjekte von LilyPond gesetzt. + Dann werden die Objekte außerhalb des Systems nach + ihrer + @code{outside-staff-priority} geordnet. Die @code{outside-staff}-Objekte + werden dann nacheinander gesetzt, mit der niedrigsten + Priorität beginnend, und so gesetzt, dass sie nicht mit anderen + Objekten kollidieren, die schon gesetzt wurden. Wenn also zwei + @code{outside-staff}-Objekte um den selben Platz streiten, + wird das mit der geringeren @code{outside-staff-priority} näher + am System gesetzt werden. Wenn zwei Objekte die selbe Priorität + haben, wird das näher am System gesetzt, welches zuerst + auftritt. + + Im folgenden Beispiel haben alle Textbeschriftungen die gleiche + Priorität (weil sie nicht explizit gesetzt worden ist). Beachten Sie, + dass @qq{Text3} wieder dicht am System gesetzt wurde, weil + er unter @qq{Text2} passt. + + @cindex Textbeschriftungsbeispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + c2^"Text1" + c^"Text2" + c^"Text3" + c^"Text4" + @end lilypond + + Notensysteme werden in den Standardeinstellungen auch so dicht + beeinander gesetzt wie es möglich ist (mit einem minimalen Abstand). + Wenn Noten sehr weit aus einem System herausragen, zwingen sie + das nächste System weiter weg, wenn eine Kollision drohen würde. + Im nächsten Beispiel sehen Sie, wie Noten auf zwei Systemen + @qq{ineinander greifen}. + + @lilypond[quote,ragged-right,verbatim] + << + \new Staff { + \relative c' { c a, } + } + \new Staff { + \relative c'''' { c a, } + } + >> + @end lilypond + + + @node within-staff (Objekte innerhalb des Notensystems) + @subsection within-staff (Objekte innerhalb des Notensystems) + @translationof Within-staff objects + + Es wurde schon gezeigt, wie die Befehle @code{\voiceXXX} die Richtung + von Bögen, Fingersatz und allen anderen Objekten beeinflusst, + die von der Richtung der Notenhälsen abhängen. Diese Befehle + sind nötig, wenn polyphone Musik geschrieben wird, damit sich + die einzelnen Melodielinien klar abzeichnen. Es kann aber von Zeit + zu Zeit nötig sein, dieses automatische Verhalten zu verändern. Das + kann entweder für ganze Abschnitte, aber genauso auch nur für eine + einzelne Note vorgenommen werden. Die Eigenschaft, die die Richtung + bestimmt, ist die @code{direction}-Eigenschaft jedes Layout-Objekts. + Es soll erst erklärt werden, was sie bewirkt und dann eine Anzahl + an fertigen Befehlen für die üblicheren Situationen präsentiert werden, + mit denen Sie gleich loslegen können. + + Manche Layout-Objekte, wie Legato- und Bindebögen, biegen sich + oder zeigen entweder nach oben oder nach unten, andere, wie + Hälse und Fähnchen, verändern auch die Position rechts oder links, + je nach der Richtung, in die sie zeigen. Das wird automatisch + berücksichtigt, wenn die @code{direction}-Eigenschaft verändert + wird. + + @funindex down + @funindex up + @funindex center + @funindex neutral + @cindex hoch-Eigenschaft + @cindex runter-Eigenschaft + @cindex zentriert-Eigenschaft + @cindex neutral-Eigenschaft + + Das folgende Beispiel zeigt im ersten Takt die Standardeinstellung + für Hälse, die bei hohen Noten nach unten zeigen und bei tiefen + noten nach oben. Im nächsten Takt werden alle Hälse nach unten + gezwungen, im dritten Takt nach oben, und im vierten wird wieder + der Standard eingestellt. + + @cindex Notenhals, Beispiel zur Veränderung + @cindex Richtungseigenschaft, Beispiel + + @lilypond[quote,verbatim,relative=2] + a4 g c a + \override Stem #'direction = #DOWN + a g c a + \override Stem #'direction = #UP + a g c a + \revert Stem #'direction + a g c a + @end lilypond + + Hier werden die Konstanten @code{DOWN} und @code{UP} + eingesetzt. Sie haben die Werte @code{-1} bwz. @code{+1}, und + diese numerischen Werte können ebenso benutzt werden. Auch + der Wert @code{0} kann in manchen Fällen benutzt werden. Er + bedeutet für die Hälse das gleiche wie @code{UP}, für einige + andere Objekte jedoch @qq{zentiert}. Es gibt hierzu die Konstante + @code{CENTER}, die den Wert @code{0} hat. + + Es gibt aber einfachere Befehle, die normalerweise benutzt werden. + Hier eine Tabelle der häufigsten. Die Bedeutung des Befehls wird + erklärt, wenn sie nicht selbsverständlich ist. + + @multitable @columnfractions .2 .2 .25 .35 + @headitem Runter/Links + @tab Rauf/Rechts + @tab Rückgängig + @tab Wirkung + @item @code{\arpeggioArrowDown} + @tab @code{\arpeggioArrowUp} + @tab @code{\arpeggioNormal} + @tab Arpeggio mit Pfeil nach unten, oben oder ohne Pfeil + @item @code{\dotsDown} + @tab @code{\dotsUp} + @tab @code{\dotsNeutral} + @tab Richtung der Verschiebung eines Punktes, um Notenlinien zu vermeiden + @item @code{\dynamicDown} + @tab @code{\dynamicUp} + @tab @code{\dynamicNeutral} + @tab Position der Dynamik-Bezeichnung relativ zum System + @item @code{\phrasingSlurDown} + @tab @code{\phrasingSlurUp} + @tab @code{\phrasingSlurNeutral} + @tab Befehl für Richtung von Phrasierungsbögen + @item @code{\slurDown} + @tab @code{\slurUp} + @tab @code{\slurNeutral} + @tab Befehl für Richtung von Legatobögen + @item @code{\stemDown} + @tab @code{\stemUp} + @tab @code{\stemNeutral} + @tab Befehl für Richtung von Hälsen + @item @code{\textSpannerDown} + @tab @code{\textSpannerUp} + @tab @code{\textSpannerNeutral} + @tab Position von Textbeschrifungen, die als Strecker eingegeben werden + @item @code{\tieDown} + @tab @code{\tieUp} + @tab @code{\tieNeutral} + @tab Befehl für Richtung von Bindebögen + @item @code{\tupletDown} + @tab @code{\tupletUp} + @tab @code{\tupletNeutral} + @tab Befehl für Richtung von Klammern/Zahlen der N-tolen + @end multitable + + Diese vordefinierten Befehl können allerdings @strong{nicht} + zusammen mit @code{\once} benutzt werden. Wenn Sie die + Wirkung eines Befehl auf eine einzige Noten begrenzen wollen, + müssen Sie den entsprechenden + @code{\once \override}-Befehl benutzen oder den definierten + Befehl, gefolgt von dem entsprechenden neutralisierenden + @code{xxxNeutral}-Befehl nach der Note. + + + @subheading Fingersatz + + @cindex Fingersatz, Positionierung + @cindex Fingersatz, Akkorde + + Die Positionierung von Fingersatz kann auch durch den Wert + seiner @code{direction}-Eigenschaft beeinflusst werden, aber + eine Veränderung von @code{direction} hat keinen Einfluss auf + Akkorde. es gibt auch hier + besondere Befehle, mit denen der Fingersatz von einzelnen + Noten in Akkorden kontrolliert werden kann, wobei mögliche + Positionen über, unter der Note und rechts bzw. links von + ihr sind. + + Zunächst die Wirkungsweise von @code{direction} auf + den Fingersatz: im ersten Takt der Standard, dann + die Wirkung von @code{DOWN} (runter) und @code{UP} + (hinauf). + + @cindex Fingersatz, Beispiel zur Veränderung + @cindex direction-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,relative=2] + c-5 a-3 f-1 c'-5 + \override Fingering #'direction = #DOWN + c-5 a-3 f-1 c'-5 + \override Fingering #'direction = #UP + c-5 a-3 f-1 c'-5 + @end lilypond + + Eine Beeinflussung der @code{direction}-Eigenschaft ist jedoch + nicht die einfachste Art, Fingersatzbezeichnungen manuell über oder + unter das System zu setzen. Normalerweise bietet es sich an, + @code{_} oder @code{^} anstelle von @code{-} vor der Fingersatz-Zahl + zu benutzen. Hier das vorherigen Beispiel mit dieser Methode: + + @cindex Fingersatz-Beispiel + + @lilypond[quote,verbatim,relative=2] + c-5 a-3 f-1 c'-5 + c_5 a_3 f_1 c'_5 + c^5 a^3 f^1 c'^5 + @end lilypond + + Die @code{direction}-Eigenschaft wirkt sich nicht auf + Akkorde aus, während die Präfixe @code{_} und @code{^} funktionieren. + Standardmäßig wird der Fingersatz automatisch entweder + über oder unter dem Akkord gesetzt: + + @cindex Fingersatz-Beispiel + + @lilypond[quote,verbatim,relative=2] + + + + @end lilypond + + @noindent + aber das kann manuell geändert werden, um einzelne Fingersatzanweisungen + nach oben oder unten zu zwingen: + + @cindex Fingersatz-Beispiel + + @lilypond[quote,verbatim,relative=2] + + + + @end lilypond + + Noch bessere Kontrolle über die Positionierung von Fingersatz für + einzelne Noten in einem Akkord ist mit dem + @code{\set fingeringOrientations}-Befehl möglich. Die Syntax + lautet: + + @example + @code{\set fingeringOrientations = #'([up] [left/right] [down])} + @end example + + @noindent + @code{\set}wird benutzt, weil @code{fingeringOrientations} eine + Eigenschaft des @code{Voice}-Kontextes ist, erstellt und eingesetzt + vom @code{New_fingering_engraver}. + + Die Eigenschaft kann als Wert eine Liste mit einem bis drei Einträgen + haben. Damit wird bestimmt, ob Fingersatz oberhalb gesetzt + werden kann (wenn @code{up} in der Liste auftaucht), darunter + (wenn@code{down} auftaucht), links (wenn @code{left} auftaucht) + oder rechts (wenn @code{right} auftaucht). Wenn andererseits + ein Wert nicht auftaucht, wir auch kein Fingersatz in dieser Richtung + gesetzt. LilyPond nimmt diese Beschränkung als Bedingung und + errechnet die besten Positionen für die Noten des nächsten Akkordes. + Die seitliche Positionierung kann nur auf einer Seite des Akkordes + geschehen, nicht auf beiden gleichzeitig, es kann also nur entweder + @code{left} oder @code{right} auftreten, nicth beide gleichzeitig. + + @warning{Damit eine einzelne Note mit diesem Befehl beeinflusst werden + kann, muss sie als ein @qq{Ein-Noten-Akkord} geschrieben + werden, indem einfache spitze Klammern um die Note positioniert + werden.} + + Hier ein paar Beispiele: + + @cindex Fingersatz-Beispiel + @cindex @code{\set}, Benutzungsbeispiel + @cindex fingerOrientations-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,relative=1] + \set fingeringOrientations = #'(left) + + < c-1 e-2 g-3 b-5 > 4 + \set fingeringOrientations = #'(left) + + < c-1 e-2 g-3 b-5 > 4 + \set fingeringOrientations = #'(up left down) + + < c-1 e-2 g-3 b-5 > 4 + \set fingeringOrientations = #'(up left) + + < c-1 e-2 g-3 b-5 > 4 + \set fingeringOrientations = #'(right) + + < c-1 e-2 g-3 b-5 > 4 + @end lilypond + + @noindent + Wenn die Fingersatzbezeichnung zu gedrungen aussieht, + kann auch die Schriftgröße (@code{font-size}) verringert + werden. Der Standardwert kann aus dem + @code{Fingering}-Objekt in der IR entnommen werden, + er ist @code{-5}, versuchen wir es also mit @code{-7}. + + @lilypond[quote,fragment,ragged-right,verbatim,relative=1] + \override Fingering #'font-size = #-7 + \set fingeringOrientations = #'(left) + + < c-1 e-2 g-3 b-5 > 4 + \set fingeringOrientations = #'(left) + + < c-1 e-2 g-3 b-5 > 4 + \set fingeringOrientations = #'(up left down) + + < c-1 e-2 g-3 b-5 > 4 + \set fingeringOrientations = #'(up left) + + < c-1 e-2 g-3 b-5 > 4 + \set fingeringOrientations = #'(right) + + < c-1 e-2 g-3 b-5 > 4 + @end lilypond + + + + @node Objekte außerhalb des Notensystems + @subsection Objekte außerhalb des Notensystems + @translationof Outside-staff objects + + Objekte außerhalb des Notensystems werden automatisch gesetzt, + um Kollisionen zu vermeiden. Objekten mit einem geringeren + Prioritätswert der Eigenschaft @code{outside-staff-priority} + werden näher an das System gesetzt, und andere Objekte außerhalb + des Systems werden dann soweit vom System entfernt gesetzt, dass + Zusammenstöße vermieden werden. Die + @code{outside-staff-priority}-Eigenschaft ist im + @code{grob-interface} definiert und ist also eine Eigenschaft + von allen Layout-Objekten. Standardmäßig ist sie für alle Objekte + auf falsch (@code{#f}) gesetzt; dieser Wert wird in einen numerischen + Wert dem Objekt entsprechend geändert, wenn das Objekt für die + Notenausgabe erstellt wird. Die Tabelle unten zeigt die + Standardwerte für die meistbenutzten @code{outside-staff}-Objekte, + die den Voreinstellungen nach im + @code{Staff}- oder @code{Voice}-Kontext gesetzt werden. + + @multitable @columnfractions .3 .3 .3 + @headitem Layout-Objekt + @tab Priorität + @tab Kontrolliert Position von: + @item @code{MultiMeasureRestText} + @tab @code{450} + @tab Text über Ganztaktpausen + @item @code{TextScript} + @tab @code{450} + @tab Textbeschriftung + @item @code{OttavaBracket} + @tab @code{400} + @tab Ottava (Oktavierungsklammern) + @item @code{TextSpanner} + @tab @code{350} + @tab Text-Strecker + @item @code{DynamicLineSpanner} + @tab @code{250} + @tab Alle Dynamik-Bezeichnungen + @item @code{VoltaBracketSpanner} + @tab @code{100} + @tab Volta-Klammern + @item @code{TrillSpanner} + @tab @code{50} + @tab Triller-Strecker + @end multitable + + Hier ein Beispiel, das die Standardpositionierung von einigen + Objekten zeigt. + + @cindex Text-Strecker + @cindex Text-Spanner + @funindex \startTextSpan + @funindex \stopTextSpan + @funindex startTextSpan + @funindex stopTextSpan + @cindex Ottava-Klammer + @cindex Oktavierungsklammer + + @cindex TextSpanner, Beispiel zur Veränderung + @cindex bound-details-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=1] + % Set details for later Text Spanner + \override TextSpanner #'(bound-details left text) + = \markup { \small \bold Slower } + % Place dynamics above staff + \dynamicUp + % Start Ottava Bracket + \ottava #1 + c' \startTextSpan + % Add Dynamic Text + c\pp + % Add Dynamic Line Spanner + c\< + % Add Text Script + c^Text + c c + % Add Dynamic Text + c\ff c \stopTextSpan + % Stop Ottava Bracket + \ottava #0 + c, c c c + @end lilypond + + Dieses Beispiel zeigt auch, wie man Text-Strecker erstellt, d.h. + Text mit Bindestrichen, der sich über eine bestimmte Länge + erstreckt. Der Strecker beginnt mit dem + @code{\startTextSpan}-Befehl und endet mit dem + @code{\stopTextSpan}-Befehl, und das Format des Textes + wird mit dem @code{\override TextSpanner}-Befehl bestimmt. + Mehr Einzelheiten siehe @ruser{Text mit Verbindungslinien}. + + Im Beispiel wird auch gezeigt, wie Oktavierungsklammern + (Ottava) erstellt werden. + + @cindex Taktzahlposition verändern + @cindex Verändern der Taktzahlposition + @cindex Position der Taktzahl, verändern + @cindex Metronom-Bezeichnungsposition verändern + @cindex Verändern der Metronom-Bezeichnungsposition + @cindex Übungszeichenposition verändern + @cindex Verändern der Übungszeichenposition + + Beachten Sie, dass Taktnummern, Metronombezeichnungen + und Übungszeichen nicht gezeigt werden. Sie werden + standardmäßig im @code{Score}-(Partitur)-Kontext + erstellt und ihre @code{outside-staff-priority} wird + in Bezug auf die Layout-Objekte, die im @code{Staff}-Kontext + erstellt werden, ignoriert. Wenn Sie Taktnummern, + Metronombezeichnungen oder Übungszeichen entsprechend + ihrer Außersystem-Priorität setzen wollen, müssen Sie + die entsprechenden Engraver (@code{Bar_number_engraver}, + @code{Metronome_mark_engraver} oder @code{Mark_engraver}) + vom @code{Score}-Kontext entfernen und dem + @code{Staff}-Kontext hinzufügen. Wenn die Engraver so + geändert werden, erhalten sie folgenden Werte für + @code{outside-staff-priority}: + + @multitable @columnfractions .3 .3 + @headitem Layout-Objekt @tab Priorität + @item @code{RehearsalMark} @tab @code{1500} + @item @code{MetronomeMark} @tab @code{1000} + @item @code{BarNumber} @tab @code{ 100} + @end multitable + + Wenn die Standardwerte der @code{outside-staff-priority} nicht + die Positionierung hervorrufen, die Sie wünschen, kann die + Priorität eines jeden Objektes geändert werden. Als Beispiel + wollen wir zeigen, wie sich die Oktavierungsklammer unter + den Textstrecker des vorigen Beispiels setzen lässt. Wir müssen + nur die Priorität des + @code{OttavaBracket}-Objektes in der IR oder der Tabelle oben + herausfinden und einen kleineren Wert angeben als der Wert, den + das @code{TextSpanner}-(Strecker)-Objekt bekommt, wobei noch daran + zu denken ist, dass @code{OttavaBracket} im @code{Staff}-Kontext + erstellt wird: + + @cindex TextSpanner, Beispiel zur Veränderung + @cindex bound-details-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=1] + % Set details for later Text Spanner + \override TextSpanner #'(bound-details left text) + = \markup { \small \bold Slower } + % Place dynamics above staff + \dynamicUp + %Place following Ottava Bracket below Text Spanners + \once \override Staff.OttavaBracket #'outside-staff-priority = #340 + % Start Ottava Bracket + \ottava #1 + c' \startTextSpan + % Add Dynamic Text + c\pp + % Add Dynamic Line Spanner + c\< + % Add Text Script + c^Text + c c + % Add Dynamic Text + c\ff c \stopTextSpan + % Stop Ottava Bracket + \ottava #0 + c, c c c + @end lilypond + + @cindex Legatobögen und outside-staff-priority + @cindex Legatobögen und Artikulationszeichen + @cindex Artikulationszeichen und Legatobögen + + Legatobögen werden als Innersystem-Objekte klassifiziert, aber + sie erscheinen oft auch über dem System, wenn die Noten, an die + sie verbunden sind, sehr hoch im System notiert sind. Dadurch + können Außersystem-Objekte, wie Artikulationszeichen, zu hoch + gerückt werden. Die @code{avoid-slur}-Eigenschaft hat nur + eine Auswirkung, wenn auch die @code{outside-staff-priority} + auf @code{#f} gesetzt ist. Alternativ kann die + @code{outside-staff-priority} des Legatobogens auf einen + numerischen Wert gesetzt werden, sodass er mit anderen + Außersystem-Objekten anhand dieses Wertes gesetzt wird. + Hier ein Beispiel, das die beiden Möglichkeiten veranschaulicht: + + @lilypond[quote,verbatim,relative=2] + c4( c^\markup\tiny\sharp d4.) c8 + c4( + \once \override TextScript #'avoid-slur = #'inside + \once \override TextScript #'outside-staff-priority = ##f + c^\markup\tiny\sharp d4.) c8 + \once \override Slur #'outside-staff-priority = #500 + c4( c^\markup\tiny\sharp d4.) c8 + @end lilypond + + Eine Änderung der @code{outside-staff-priority} kann auch dazu + benutzt werden, die vertikale Plazierung von individuellen Objekten + zu kontrollieren, auch wenn das Ergebnis nicht immer optimal + ist. Im nächsten Beispiel soll @qq{Text3} oberhalb von @qq{Text4} + gesetzt werden, das Beispiel wurde behandelt in + @ref{Automatisches Verhalten}. Der Wert der Priorität muss also für + die Eigenschaft @code{TextScript} entweder in der IR oder in der + Tabelle oben festgestellt werden und dann die Priorität für + @qq{Text3} höher eingestellt werden: + + @cindex TextScript, Beispiel zur Veränderung + @cindex outside-staff-priority-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + c2^"Text1" + c^"Text2" + \once \override TextScript #'outside-staff-priority = #500 + c^"Text3" + c^"Text4" + @end lilypond + + Damit wird zwar @qq{Text3} ganz richtig über @qq{Text4} + platziert, aber auch über @qq{Text2}, und @qq{Text4} + wird jetzt weiter unten gesetzt. Eigentlich sollten ja alle + diese Anmerkungen gleichweit vom System entfernt sein. + Dazu muss offensichtlich horizontal etwas Platz gemacht + werden. Das kann erreicht werden mit dem + @code{textLengthOn}-(Textlänge an)-Befehl. + + @subheading \textLengthOn (Textlänge berücksichtigen) + + @cindex Noten, durch Text gespreizt + @funindex \textLengthOn + @funindex textLengthOn + @funindex \textLengthOff + @funindex textLengthOff + + Standardmäßig wird Text, der mit dem Beschriftungsbefehl + @code{\markup} bzw. Äquivalenten erstellt wird, kein + zusätzlicher Platz in Bezug auf die Positionierung der Noten + zugestanden. Der @code{\textLengthOn}-Befehl ändert + dieses Verhalten, so dass die Noten gespreizt werden, wenn + die Breite des Textes es erfordert: + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + \textLengthOn % Cause notes to space out to accommodate text + c2^"Text1" + c^"Text2" + c^"Text3" + c^"Text4" + @end lilypond + + Dieses Verhalten wird mit dem @code{\textLengthOff}-Befehl + rückgängig gemacht. Erinnern Sie sich, dass @code{\once} nur mit + @code{\override}, @code{\set}, @code{\revert} oder @code{unset} + funktioniert, der Befehl kann also nicht zusammen mit + @code{\textLengthOn} benutzt werden. + + @cindex Textbeschriftung, Vermeidung von Zusammenstößen + @cindex Zusammenstöße vermeiden mit Textbeschriftung + + Textbeschriftung vermeidet auch Noten, die über das System hinausstehen. + Wenn das nicht gewünscht ist, kann die automatische Verschiebung + nach oben hin auch vollständig ausgeschaltet werden, indem die + Priorität auf @code{#f} gesetzt wird. Hier ein Beispiel, wie + eine Textbeschriftung mit diesen Noten reagiert: + + @cindex Textbeschriftung, Beispiel zur Veränderung + @cindex outside-staff-priority-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + % This markup is short enough to fit without collision + c2^"Tex" + c''2 + R1 + % This is too long to fit, so it is displaced upwards + c,,2^"Text" + c''2 + R1 + % Turn off collision avoidance + \once \override TextScript #'outside-staff-priority = ##f + c,,2^"Long Text " + c''2 + R1 + % Turn off collision avoidance + \once \override TextScript #'outside-staff-priority = ##f + \textLengthOn % and turn on textLengthOn + c,,2^"Long Text " % Spaces at end are honored + c''2 + @end lilypond + + + @subheading Dynamik + + @cindex Verändern der Positionierung von Dynamikzeichen + @cindex Dynamikzeichen: Positionierung verändern + + Dynamikbezeichnung wird üblicherweise unter dem System + gesetzt, kann aber auch nach oben mit dem Befehl + @code{dynamicUp} gezwungen werden. Die Bezeichnung + wird vertikal relativ zu der Note positioniert, an die sie angefügt + wurde. Sie wird vertikal variabel gesetzt in Bezug zu + Innersystemobjekten wie Bögen oder Taktnummern. Damit + können oft recht gute Resultate erreicht werden, wie im + folgenden Beispiel: + + @lilypond[quote,fragment,ragged-right,verbatim,relative=1] + \clef "bass" + \key aes \major + \time 9/8 + \dynamicUp + bes4.~\f\< \( bes4 bes8 des4\ff\> c16 bes\! | + ees,2.~\)\mf ees4 r8 | + @end lilypond + + Wenn aber Noten und Dynamikzeichen sehr dicht beieinander + stehen, positioniert die automatische Kollisionsvermeidung + später kommende Dynamikzeichen weiter weg, was allerdings + nicht immer die beste Möglichkeit ist, wie in dem folgenden, + etwas gewollten Beispiel zu sehen ist: + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + \dynamicUp + a4\f b\mf c\mp b\p + @end lilypond + + @noindent + Wenn eine ähnliche Situation in @qq{echter} Musik auftaucht, + kann es nötig sein, die Noten etwas zu spreizen, damit die + Dynamikzeichen alle auf der selben vertikalen Position + gesetzt werden können. Dieses Verhalten war im Falle von + Textbeschriftungen möglich mit dem @code{\textLengthOn}-Befehl, + aber es gibt keinen entsprechenden Befehl für Dynamik. Wir + müssen also unsere eigenen Befehle mit @code{\override} + konstruieren. + + + @subheading Verändern der Größe von grobs + + @cindex Grob, Größenveränderung + @cindex Größenveränderung von grobs + + Zuallererst müssen wir lernen, wie die Größe von Grobs verändert + wird. Alle Grobs besitzen einen Referenzpunkt, der + benutzt wird, um ihre Position in Relation zu ihnen übergeordneten + Objekten zu bestimmen. Dieser Punkt innerhalb des Grobs wird dann + auf einer horizontalen Position (@code{X-offset}) und einer + vertikalen Position (@code{Y-offset}) ausgerichtet, immer bezüglich + des übergeordneten Objektes. Eine horizontale Strecke wird + durch ein Zahlenpaar angegeben (@code{X-extent}), welche + die linke und rechte Grenze relativ zum übergeordneten Objekt + bezeichnen. Die vertikale Strecke wir genauso durch ein + Zahlenpaar (@code{Y-extent}) definiert. Diese Eigenschaften + gehören zu allen Grobs, die das + @code{grob-interface} unterstützen. + + @cindex @code{extra-spacing-width} + + Standardmäßig haben Außersystemobjekte eine Länge von Null, + so dass sie sich in horizontaler Richtung überlappen können. Das + geschieht, indem dem linken Rand Unendlich zugewiesen wird + und dem rechten Rand minus Undendlich (der Code der + @code{extra-spacing-width}-(zusätzliche Positionierungslänge)-Eigenschaft + lautet: @code{'(+inf.0 . -inf.0)}). + Damit sich diese Objekte also horizontal nicht überschneiden, muss + der Wert von @code{extra-spacing-width} auf + @code{'(0 . 0)} gesetzt werden, sodass die wirkliche Länge eines + Objektes zur Geltung kommt. Mit diesem Befehl wird das für + Dynamik-Zeichen erledigt: + + @example + \override DynamicText #'extra-spacing-width = #'(0 . 0) + @end example + + @noindent + Schauen wir uns an, wie es mit dem vorigen Beispiel funktioniert: + + @cindex DynamicText, Beispiel zur Veränderung + @cindex extra-spacing-width-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + \dynamicUp + \override DynamicText #'extra-spacing-width = #'(0 . 0) + a4\f b\mf c\mp b\p + @end lilypond + + @noindent + Damit werden die Dynamik-Zeichen also wirklich nebeneinander + gesetzt, aber es gibt noch zwei Probleme. Die Zeichen sollten + etwas weiter außeinander stehen und es wäre gut, wenn sie alle + den gleichen Abstand zum System hätte. Das erste Problem ist + einfach behoben. Anstatt der @code{extra-spacing-width}-Eigenschaft + Null zuzuweisen, können wir auch einen etwas größeren Wert + wählen. Die Einheit wird gemessen in dem Abstand zwischen zwei + Notenlinien, es scheint also gut, den rechten und linken + Rand eine halbe Einheit zu vergrößern: + + @cindex DynamicText, Beispiel zur Veränderung + @cindex extra-spacing-width-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + \dynamicUp + % Extend width by 1 staff space + \override DynamicText #'extra-spacing-width = #'(-0.5 . 0.5) + a4\f b\mf c\mp b\p + @end lilypond + + @noindent + Das sieht schon besser aus, aber es wäre noch besser, wenn die + Dynamik-Zeichen alle an einer Linie ausgerichtet wären, anstatt + höher und tiefer zu sitzen. Das kann mit der + @code{staff-padding}-Eigenschaft erreicht werden, + die wir uns im folgenden Abschnitt genauer anschauen werden. + + + + @node Kollision von Objekten + @section Kollision von Objekten + @translationof Collisions of objects + + @menu + * Verschieben von Objekten:: + * Überlappende Notation in Ordnung bringen:: + * Beispiele aus dem Leben:: + @end menu + + @node Verschieben von Objekten + @subsection Verschieben von Objekten + @translationof Moving objects + + @cindex Verschieben von überschneidenden Objekten + @cindex Verschieben von Zusammenstößen + @cindex Zusammenstöße vermeiden + @cindex Objekte, verschieben von Zusammestößen + @cindex Vermeiden von Zusammenstößen + + Es wird vielleicht eine Überraschung sein, aber LilyPond ist nicht + perfekt. Einige Notationselemente können sich überschneiden. Das + ist nicht schön, aber zum Glück sehr selten. Normalerweise müssen + die Objekte zur Klarheit oder aus ästhetischen Gründen verschoben + werden -- sie könnten besser aussehen, wenn sie etwas zusätzlichen + Platz erhalten. + + Es gibt im Grunde drei Herangehensweisen, überlappende Notation + zu verbessern. Man sollte sie in der folgenden Reihenfolge + anwenden: + + @enumerate + @item + Die @strong{Richtung} eines der überlappenden Objekte kann + geändert werden, indem die vordefinierten Befehle für + Innersystemobjekte verwendet werden, wie beschrieben in + @ref{within-staff (Objekte innerhalb des Notensystems)}. Hälse, Bögen, Balken, Dynamik-Zeichen + und Triolen können auf diese Weise einfach umgeordnet + werden. Beschränkt ist diese Methode insofern, als es nur + zwei Möglichkeiten zur Veränderung gibt: oben oder unten. + + @item + Die @strong{Objekteigenschaft}, die LilyPond benutzt um die + Layout-Objekte zu platzieren, können mit dem + @code{\override}-Befehl positioniert werden. Die Vorteile + von Änderungen dieser Art sind a) dass einige Objekte + automatisch verschoben werden, wenn es nötig ist Platz zu + schaffen und b) ein einziges @code{\override} sich auf + alle Fälle eines Objekttyps bezieht. Zu diesen Eigenschaften + gehören: + + @itemize + + @item + @code{direction} (Richtung) + + Das wurde schon detailliert behandelt, siehe + @ref{within-staff (Objekte innerhalb des Notensystems)}. + + @item + @code{padding}, @code{left-padding}, + @code{right-padding}, @code{staff-padding} (Verschiebung) + + @cindex left-padding-Eigenschaft + @cindex Padding-Eigenschaft + @cindex right-padding-Eigenschaft + @cindex staff-padding-Eigenschaft + @cindex Verschieben (padding) + @cindex Füllung (padding) + @cindex padding (Füllung) + + Wenn ein Objekt platziert wird, bestimmt der Wert seiner + @code{padding}-(Füllungs)-Eigenschaft die Größe des + Abstandes, der zwischen dem Objekt selber und dem + Objekt, relativ zu welchem es positioniert wird, gelassen + werden muss. Dabei zählt der @code{padding}-Wert + des Objektes, das platziert werden soll, der @code{padding}-Wert + des Objektes, das schon gesetzt wurde, wird hingegegen + ignoriert. Abstände mit @code{padding} können zu + allen Objekten hinzugefügt werden, die das + @code{side-position-interface} unterstützen. + + Anstelle von @code{padding} wird die Position von + Versetzungszeichengruppen durch die Eigenschaften + @code{left-padding} und @code{right-padding} bestimmt. + Diese Eigenschaften werden im + @code{AccidentalPlacement}-(Versetzungszeichen-Positionierungs)-Objekt + gefunden, das sich innerhalb des @strong{Staff}-Kontexts + befindet. Während des Notensatzes werden die Notenköpfe + zuerst gesetzt und dann die Versetzungszeichen, wenn denn + welche gesetzt werden, durch die @code{right-padding}-Eigenschaft + auf die linke Seite der Notenköpfe positioniert, um die Entfernung + von den Notenköpfen zu bestimmen. Also nur die + @code{right-padding}-(Verschiebung nach rechts)-Eigenschaft des + @code{AccidentalPlacement}-Objekts hat Einfluss auf die + Positionierung der Versetzungszeichen. + + Die @code{staff-padding}-(Verschiebung zum System)-Eigenschaft + ist sehr ähnlich wie die @code{padding}-Eigenschaft: + @code{padding} bestimmt den Minimalabstand zwischen + einem Objekt, das das @code{side-position-interface} + unterstützt, und dem nächsten anderen Objekt (normalerweise + die Note oder Notenlinie); @code{staff-padding} dagegen + wirkt nur auf Objekte die immer außerhalb des Notensystems + sind -- damit wird der minimale Abstand bestimmt, der + zwischen dem Objekt und dem Notensystem gelassen werden + soll. @code{staff-padding} hat also @strong{keinen Einfluss} + auf Objekte, die relativ zu einer Note positioniert werden, sondern + nur auf solche, die zum System relativ stehen. Wenn es mit einem + anderen Objekt eingesetzt wird, erhält man keine Fehlermeldung, aber + der Befehl hat auch keine Auswirkungen. + + Um herauszufinden, welche @code{padding}-Eigenschaft für + das bestimmte Objekt nötig, ist, das Sie verschieben wollen, + müssen Sie in der IR nach den Objekt-Eigenschaften schauen. + Dabei sollten Sie bedenken, dass sich die @code{padding}-Eigenschaften + nicht unbedingt in dem Objekt selber befinden, schauen Sie + also auch in Objekten nach, die offensichtlich Ähnlichkeiten + haben. + + Alle @code{padding}-Werte werden in Notenlinienabständen + gemessen. Für die meisten Objekte ist der Wert ungefähr auf + 1.0 oder weniger gesetzt (das variiert von Objekt zu Objekt). + Der Wert kann geändert werden, wenn ein größerer (oder + kleinerer) Abstand gewünscht wird. + + @item + @code{self-alignment-X} (Selbstpositionierung) + + @cindex self-alignment-X-Eigenschaft + @cindex Selbstpositionierung von Objekten + @cindex Ausrichtung von Objekten + + Diese Eigenschaft kann benutzt werden, um ein Objekt + nach links, rechts oder zentriert an dem Referenzpunkt des Objekts + auszurichten, an das es verknüpft ist. Es kann bei allen + Objekten benutzt werden, die das @code{self-alignment-interface} + unterstützen. Das sind üblicherweise Objekte, die Text + enthalten. Die möglichen Werte der Eigenschaft sind @code{LEFT}, + @code{RIGHT} oder @code{CENTER}. Alternativ kann ein + numerischer Wert zwischen @code{-1} und @code{+1} + bestimmt werden: @code{-1} heißt linksbündig, @code{+1} + rechtsbündig und Zahlen dazwischen bewegen den Text + schrittweise von links nach rechts. Zahlen größer als + @code{1} können angegeben werdne, um den Text + noch weiter nach links zu bewegen, oder weniger als @code{-1}, + um ihn weiter nach rechts zu schieben. Eine Änderung + um @code{1} des Wertes entspricht einer Bewegung um + die halbe Textbreite. + + @item + @code{extra-spacing-width} (zusätzliche Breite) + + @cindex extra-spacing-width-Eigenschaft + + Diese Eigenschaft steht für alle Objekte zur Verfügung, die + das @code{item-interface} unterstützen. Es braucht zwei + Zahlen als Argument, die erste wird zur rechten Ausdehnung, + die zweite zur linken Ausdehnung hinzugerechnet. Negative + Zahlen verschieben die Ausdehnung nach rechts, positive nach + links, um also ein Objekt zu verbreitern, muss die erste + Zahl negativ und die zweite positiv sein. Allerdings beachten + nicht alle Objekte beide Zahlen. Das + @code{accidental}-(Versetzungszeichen)-Objekt etwa beachtet + nur erste Zahl für die linke Ausdehnung. + + @item + @code{staff-position} (Notensystempositionierung) + + @cindex staff-position-Eigenschaft + + @code{staff-position} ist eine Eigenschaft des + @code{staff-symbol-referencer-interface}, die von Objekten unterstützt + wird, die relativ zum Notensystem (engl. staff) positioniert werden. + Hiermit wird die vertikale Position eines Objekts relativ zur + Mittellinie des Systems in halben Notenlinienabständen angegeben. + Das ist sehr nützlich, um Zusammenstöße zwischen Layout-Objekten + wie Ganztaktpausen, Bögen und Noten in verschiedenen Stimmen + zu lösen. + + @item + @code{force-hshift} (vertikale Verschiebung erzwingen) + + @cindex force-hshift-Eigenschaft + + Eng beeinander stehende Noten in einem Akkord oder Noten, die zum + gleichen Zeitpunkt in unterschiedlichen Stimmen stehen, werden + in zwei oder manchmal auch mehr Kolumnen gesetzt, um Kollisionen + zu umgehen. Diese Kolumnen werden Notenkolumnen genannt; + ein @code{NoteColumn}-Objekt wird erstellt um die Noten in den + Kolumnen zu setzen. + + Die @code{force-hshift}-(erzwinge horizontale Verschiebung)-Eigenschaft + ist eine Eigenschaft von @code{NoteColumn} (bzw. vom + @code{note-column-interface}). Eine Veränderung dieser Eigenschaft + macht es möglich, eine Notenkolumne zu verschieben, dabei gilt als + Einheit die Breite einer Kolumne, also die Breite des Notenkopfes der + ersten Stimme. Diese Eigenschaft kann in Situationen benutzt werden, + in denen die normalen @code{\shiftOn}-Befehle (siehe auch + @ref{Stimmen explizit beginnen}) das Problem nicht beseitigen. + Diese Eigenschaft ist besser in solchen Fällen zu verwenden als die + @code{extra-offset}-Eigenschaft, weil man die richtige Entfernung nicht + in Notenlinienabständen ausrechnen muss. Wenn eine Note in eine + Notenkolumne oder aus ihr heraus geschoben wird, werden auch andere + Funktionen beeinflusst, wie etwa die Verschmelzung von Notenköpfen. + + @end itemize + + @item + Zu guter Letzt, wenn alles andere nicht funktioniert, können Objekte auch + manuell positioniert werden, entweder vertikal in Bezug auf die + Mittellinie des Systems, oder indem sie einen beliebigen Abstand weit + auf eine neue Position verschoben werden. Der Nachteil ist, dass die + richtigen Werte für eine gute Position manuell ausprobiert werden müssen, + meistens durch Herantasten an den richtigen Wert, und das für jedes + einzelne Objekt extra. Und weil diese Verschiebungen erst vorgenommen + werden, wenn LilyPond alle anderen Objekte gesetzt hat, ist man als + Notensetzer selber dafür verantwortlich, ob es Zusammenstöße gibt. + Am schwerwiegendsten ist aber die Tatsache, dass die + Verschiebungskoordinaten wahrscheinlich neu errechnent oder + ausprobiert werden müssen, wenn sich an den Noten und deren + Layout später irgend etwas ändert. Die Eigenschaften, die für diese + Arte der manuellen Verschiebung verwendet werden können, sind: + + @table @code + @item extra-offset (zusätzlicher Abstand) + + @cindex extra-offset-Eigenschaft + + Diese Eigenschaft gehört zu jedem Layout-Objekt, das das + @code{grob-interface} unterstützt. Sie braucht ein Zahlenpaar, + das die exakte Verschiebung in horizontaler und vertikaler Richtung + bezeichnet. Negative Zahlen verschieben das Objekt nach links oder + unten. Die Einheit sind Notenlinienabstände. Die zusätzliche + Positionierung wird vorgenommen, nachdem alle anderen Objekte + platziert sind, weshalb ein Objekt irgendwohin verschoben werden + kann, ohne den restlichen Satz zu beeinflussen. + + @item positions (Position) + + @cindex positions-Eigenschaft + + Diese Eigenschaft ist am sinnvollsten, um die Steigung und die + Höhe von Balken, Bögen und Triolenklammern anzupassen. + Sie braucht ein Zahlenpaar, das die Position des rechten und linken + Endes relativ zur Mittellinie des Notensystems bestimmt. Die + Einheit sind Notenlinienabstände. Bögen allerdings können nicht + beliebig weit weg positioniert werden. LilyPond erstellt zunächst eine + Liste an möglichen Positionen für den Bogen und findet normalerweise + die Version, die @qq{am besten aussieht}. Wenn die + @code{positions}-Eigenschaft verändert worden ist, wird der + Bogen aus der Liste gewählt, der der gewünschten Position am + nächsten kommt. + @end table + + @end enumerate + + Ein bestimmtes Objekt hat vielleicht nicht alle dieser Eigenschaften. + Darum ist es nötig, in der IR nachzuschlagen, welche Eigenschaften + ein bestimmtes Objekt unterstützt. + + Hier ist eine Liste an Objekten, die am wahrscheinlichsten an einer + Kollision beteiligt sind, daneben findet sich die Bezeichnung des + Objektes, mit der Sie es in der IR finden, um zu bestimmen, + welche Eigenschaften benutzt werden können, um es zu verschieben. + + @multitable @columnfractions .5 .5 + @headitem Objekttyp @tab Objektbezeichnung + @item Articulationszeichen @tab @code{Script} + @item Balken @tab @code{Beam} + @item Dynamikzeichen (vertikal) @tab @code{DynamicLineSpanner} + @item Dynamikzeichen (horizontal) @tab @code{DynamicText} + @item Fingersatz @tab @code{Fingering} + @item Übungs-/Textmarken @tab @code{RehearsalMark} + @item Legatobögen @tab @code{Slur} + @item Text z. B. @code{^"text"} @tab @code{TextScript} + @item Bindebögen @tab @code{Tie} + @item N-tolen @tab @code{TupletBracket} + @end multitable + + + @node Überlappende Notation in Ordnung bringen + @subsection Überlappende Notation in Ordnung bringen + @translationof Fixing overlapping notation + + Hier soll nun gezeigt werden, wie die Eigenschaften, die im + vorigen Abschnitt vorgestellt wurden, bei der Problemlösung + mit sich überschneidenden Notationselementen eingesetzt + werden können. + + @subheading padding (Fülleigenschafte) + + @cindex padding (Verschiebungs-Eigenschaft) + @cindex Überschneidende Notation korrigieren + @cindex Korrigieren von überschneidender Notation + + Die @code{padding}-(Verschiebungs-)Eigenschaft kann benutzt + werden, um den Abstand zwischen Symbolen zu vergößern (oder + zu verkleinern), die über oder unter den Noten gesetzt werden. + + @cindex Script, Beispiel zur Veränderung + @cindex Verschiebungs-Eigenschaft, Beispiel + @cindex padding (Verschiebuns-Eigenschaft), Beispiel + + @lilypond[quote,fragment,relative=1,verbatim] + c2\fermata + \override Script #'padding = #3 + b2\fermata + @end lilypond + + @cindex MetronomMark, Beispiel zur Veränderung + @cindex Verschiebungs-Eigenschaft, Beispiel + @cindex padding (Verschiebuns-Eigenschaft), Beispiel + + @lilypond[quote,fragment,relative=1,verbatim] + % This will not work, see below: + \override MetronomeMark #'padding = #3 + \tempo 4=120 + c1 + % This works: + \override Score.MetronomeMark #'padding = #3 + \tempo 4=80 + d1 + @end lilypond + + Im zweiten Beispiel können Sie sehen, wie wichtig es ist den richtigen + Kontext anzugeben. Weil das @code{MetronomeMark}-Objekt + sich im @code{Score}-Kontext befindet, werden Eigenschaftsänderungen + im @code{Voice}-Kontext einfach ignoriert. Für mehr Einzelheiten siehe + @ruser{Eignschaften verändern}. + + Wenn die @code{padding}-Eigenschaft eines Objektes erhöht wird, das + sich in einem Stapel von Objekten befindet, die nach ihrer + Außersystempriorität (@code{outside-staff-priority}) positioniert werden, + werden das Objekt und alle, die sich außerhalb davon befinden, + entsprechend verschoben. + + @subheading left-padding (Verschieben nach rechts) und right-padding (Verschieben nach links) + + @cindex left-padding-Eigenschaft (Verschiebung nach links) + @cindex Verschiebung nach rechts oder links + @cindex right-padding-Eigenschaft (Verschiebung nach rechts) + + Die @code{right-padding}-Eigenschaft wirkt sich auf den Abstand + zwischen einem Versetzungszeichen und der Note, auf das sie sich + bezieht, aus. Sie wird nicht sehr oft benötigt, aber das folgende + Beispiel zeigt eine Situation, wo man sie braucht. Das Beispiel + stellt eine Situation dar, in der in einem Akkord sowohl H als auch + B vorkommen sollen. Damit keine Ambiguität ensteht, sollen beide + Noten ein Zeichen haben, also ein B und ein Auflösungszeichen. + Hier einige Notationsversuche: + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + + + + @end lilypond + + @noindent + Keiner davon funktioniert, und der zweite und dritte weist + hässliche Zusammenstöße zwischen den Zeichen auf. + + Eine Möglichkeit, das Gewünschte zu erhalten, ist es den + Stencil des Versetzungszeichens zu ersetzen mit einer + Textbeschriftung (Markup), die sowohl das B als auch das + Aulösungszeichen enthält: + + @cindex Versetzungszeichen, Beispiel zur Veränderung + @cindex Accidental, Beispiel zur Veränderung + @cindex Text-Eigenschaft, Beispiel + @cindex stencil-Eigenschaft, Beispiel + @cindex AccidentalPlacement, Beispiel zur Veränderung + @cindex right-padding-Eigenschaft, Beispiel + @cindex Verschiebung nach rechts (rigth-padding), Beispiel + + @lilypond[quote,ragged-right,verbatim] + naturalplusflat = \markup { \natural \flat } + \relative c'' { + \once \override Accidental + #'stencil = #ly:text-interface::print + \once \override Accidental #'text = #naturalplusflat + \once \override Score.AccidentalPlacement #'right-padding = #1.5 + + } + @end lilypond + + @noindent + Dazu ist aber ein @code{\override}-Befehl für den Stencil des + Versetzungszeichens nötig, der bisher nicht behandelt wurde. + Der Typ des Stencils muss eine Prozedur sein, die hier geändert + wurde, um den Inhalt der @code{text}-Eigenschaft des + @code{Accidental} (Versetzungszeichen)-Objekts zu setzen, + die dann so definiert wird, dass sie ein Auflösungszeichen gefolgt + von einem B enthält. Diese werden dann mit @code{right-padding} + weiter nach rechts verschoben. + + + @subheading staff-padding (Systemfüllungseigenschaft) + + @cindex staff-padding-Eigenschaft + @cindex Objekte an der Grundlinie ausrichten + @cindex Ausrichten von Objekten an der Grundlinie + + @code{staff-padding} (Verschiebung zum Notensystem) kann + verwendet werden um Objekte wie Dynamikzeichen an einer + Grundlinie auf einer bestimmten Höhe über dem System + auszurichten, sodass sie nicht von der Position der Note abhängen, + an die sie angehängt sind. Diese Verschiebung ist keine Eigenschaft + von @code{DynamicText}, sondern von @code{DynamicLineSpanner}. + Das liegt daran, dass die Grundlinie sich gleicherweise auf + @strong{alle} Dynamikzeichen beziehen soll, also auch auf die, + die als Strecker erstellt wurden. Hier also die Lösung, die Dynamikzeichen + aus dem Beispiel des vorigen Abschnitts auszurichten: + + @cindex DynamikText, Beispiel zur Veränderung + @cindex extra-spacing-width-Eigenschaft, Beispiel + @cindex DynamicLineSpanner, Beispiel zur Veränderung + @cindex staff-padding-Eigenschaft, Beispiel + + @lilypond[quote,fragment,ragged-right,verbatim,relative=2] + \dynamicUp + % Extend width by 1 unit + \override DynamicText #'extra-spacing-width = #'(-0.5 . 0.5) + % Align dynamics to a base line 2 units above staff + \override DynamicLineSpanner #'staff-padding = #2 + a4\f b\mf c\mp b\p + @end lilypond + + + @subheading self-alignment-X (Selbstausrichtung-X-Eigenschaft) + + @cindex self-alignment-X-Eigenschaft + + Das nächste Beispiel zeigt, wie man den Zusammenstoß + einer Fingersatzbezeichnung mit einem Notenhals + verhindern kann, indem die rechte Ecke an dem + Referenzpunkt der abhängigen Note angeordnet wird: + + @cindex StringNumber, Beispiel zur Veränderung + + @lilypond[quote,fragment,ragged-right,verbatim,relative=3] + \voiceOne + < a \2 > + \once \override StringNumber #'self-alignment-X = #RIGHT + < a \2 > + @end lilypond + + + @subheading staff-position (Position innerhalb des Systems) + + @cindex staff-position-Eigenschaft + @cindex Notensystem-Position-Eigenschaft + @cindex Kollision von Objekten im System + @cindex Zusammenstöße von Objekten im System + + Vieltaktpausen in einer Stimmen können mit Noten in anderen + Stimmen kollidieren. Da diese Pausen zentriert zwischen den + Taktlinien gesetzt werden, würde es für LilyPond eine recht große + Anstrengung bedeuten herauszufinden, welche Noten mit ihnen + zusammenstoßen könnten, denn alle Kollisionsvermeidung + für Noten und Pausen funktioniert nur für Noten bzw. Pausen, die + zur selben Zeit auftreten. Hier ein typisches Beispiel für eine + Kollision dieser Art: + + @lilypond[quote,verbatim,fragment,ragged-right, relative=1] + << {c c c c} \\ {R1} >> + @end lilypond + + Die beste Lösung ist es, die Ganztaktpause nach unten zu + schieben, denn die Pause ist in der zweiten Stimme. Per + Standardeinstellung für die zweite Stimme (@code{\voiceTwo}, + also die zweite Stimme in der + @code{<<@{...@} \\ @{...@}>>}-Konstruktion) wird die + Position auf dem System (@code{staff-position}) auf -4 + für @code{MultiMeasureRest}, in unserem Beispiel muss + es also bspw. auf die Position @code{-8} gesetzt werden, + d.h. vier halbe Notenlinienabstände weiter nach unten: + + @cindex MultiMeasureRest, Beispiel zur Veränderung + @cindex Ganztaktpausen, Beispiel zur Veränderung + @cindex staff-position-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,fragment,ragged-right, relative=1] + << + {c c c c} + \\ + \override MultiMeasureRest #'staff-position = #-8 + {R1} + >> + @end lilypond + + Das ist besser, als etwa @code{extra-offset} zu benutzen, denn + in unserem Fall wird die Hilfslinie der Pause automatisch gesetzt. + + + @subheading extra-offset (Genaues Positionieren) + + @cindex extra-offset-Eigenschaft + @cindex Zusätzlicher Abstand, Positionierung + @cindex Positionierung von Objekten + @cindex Objekte, Positionierung + + Die @code{extra-offset}-Eigenschaft bietet vollständige Kontrolle + über die Positionierung von Objekten in horizontaler und vertikaler + Richtung. + + Im Beispiel unten ist das zweite Fingersatzzeichen (@code{Fingering}) etwas nach + links und 1,8 Notenlinienabstände nach unten verschoben: + + @cindex Fingersatz, Beispiel zur Veränderung + @cindex extra-offset-Eigenschaft, Beispiel + + @lilypond[quote,fragment,relative=1,verbatim] + \stemUp + f-5 + \once \override Fingering + #'extra-offset = #'(-0.3 . -1.8) + f-5 + @end lilypond + + + @subheading Ausrichtungseigenschaft + + @cindex positions-Eigenschaft + @cindex Kontrolle über Triolen, Bögen und Balken manuell + @cindex manuelle Kontrolle über Triolen, Bögen, Balken + @cindex Balken, manuelle Kontrolle + @cindex Bögen, manuelle Kontrolle + @cindex Legatobögen, manuelle Kontrolle + @cindex Phrasierungsbögen, manuelle Kontrolle + @cindex Triollen-Klammer, manuelle Kontrolle + + Die @code{positions}-Eigenschaft erlaubt die Kontrolle von Position und + Steigung von Balken, Legato- und Phrasierungsbögen sowie Triolenklammern. + Hier ein Beispiel, in der ein unschöner Phrasierungsbogen auftritt, weil + er den Bogen des Vorschlags vermeidet: + + @lilypond[quote,verbatim,fragment,ragged-right,relative=1] + r4 \acciaccatura e8\( d8 c ~c d c d\) + @end lilypond + + @noindent + Man könnte einfach den Phrasierungsbogen oberhalb der Noten setzen, und + das wäre auch die beste Lösung: + + @cindex Phrasierungsbogen, Beispiel zur Veränderung + @cindex positions-Eigenschaft, Beispiel + @cindex Positionierung, Beispiel + + @lilypond[quote,verbatim,fragment,ragged-right,relative=1] + r4 + \phrasingSlurUp + \acciaccatura e8\( d8 c ~c d c d\) + @end lilypond + + @noindent + aber wenn es einen Grund geben sollte, warum das nicht geht, könnte + man das linke Ende des Phrasierungsbogens etwas nach unten verschieben, + indem man die @code{positions}-Eigenschaft einsetzt. Damit + verschwindet auch die etwas unschöne Form: + + @lilypond[quote,verbatim,fragment,ragged-right,relative=1] + r4 + \once \override PhrasingSlur #'positions = #'(-4 . -3) + \acciaccatura + e8\( d8 c ~c d c d\) + @end lilypond + + Hier noch ein weiteres Beispiel aus der Einleitung von Chopins + Prelude Op. 28 Nr. 2, das untere System. Wie zu sehen ist, + stößt der Balken mit den oberen Noten zusammen: + + @lilypond[quote,verbatim,fragment,ragged-right] + { + \clef "bass" + << {b,8 ais, b, g,} \\ {e, g e, g} >> + << {b,8 ais, b, g,} \\ {e, g e, g} >> + } + @end lilypond + + @noindent + Das kann manuell gelöst werden, indem beide Enden des Balkens + von ihrer Position 2 Notenlinienabstände über der Mittellinie + hochgeschoben werden, etwa auf 3: + + @cindex Balken, Beispiel zur Veränderung + @cindex positions-Eigenschaft, Beispiel + @cindex Positionierung, Beispiel + + @lilypond[quote,verbatim,fragment,ragged-right] + { + \clef "bass" + << + \override Beam #'positions = #'(3 . 3) + {b,8 ais, b, g,} + \\ + {e, g e, g} + >> + << {b,8 ais, b, g,} \\ {e, g e, g} >> + } + @end lilypond + + @noindent + Hier ist zu beobachten, dass die Veränderung sich auch auf die + weiteren Achtelbalken der ersten Stimme auwirkt, während sie keine + Auswirkung auf die Balken der zweiten Stimme hat. + + @subheading force-hshift (vertikale Verschiebunseigenschaft) + + @cindex force-hshift-Eigenschaft + @cindex Vertikale Verschiebung erzwingen + + @c FIXME: formatting stuff (ie not important right now IMO) + @c @a nchor Chopin finally corrected TODOgp + + An diesem Punkt können wir den letzten Feinschliff an unserem + Chopin-Beispiel vornhemen, das wir behandelt haben in + @ref{Ich höre Stimmen}. Wir hatten es in folgende Form + gebracht: + + @lilypond[quote,verbatim,fragment,ragged-right] + \new Staff \relative c'' { + \key aes \major + << + { c2 aes4. bes8 } \\ + { aes2 f4 fes } \\ + { \voiceFour + 2 + des2 + } + >> | + 1 | + } + @end lilypond + + @noindent + Die unteren zwei Noten des ersten Akkords (also diein der + dritten Stimme) sollten nicht aus der Notenkolumne der + oberen zwei Noten weggeschoben werden. Um das zu + korrigieren, setzen wir @code{force-hshift}, das eine + Eigenschaft von + @code{NoteColumn} ist, für diese Noten auf Null. + Die untere Note des zweiten Akkordes wird am besten + direkt rechts von den oberen Noten gesetzt. Das erreichen + wir, indem wir @code{force-hshift} für diese Note auf + 0.5 setzen, also eine halbe Notenkopfbreite nach rechts von + der Kolumne der oberen Noten aus. + + Hier das Endergebnis: + + @cindex Notenkolumne, Beispiel zur Veränderung + @cindex force-hshift-Eigenschaft, Beispiel + @cindex vertikale Verschiebung, Beispiel + + @lilypond[quote,verbatim,fragment,ragged-right] + \new Staff \relative c'' { + \key aes \major + << + { c2 aes4. bes8 } \\ + { aes2 f4 fes } \\ + { \voiceFour + \once \override NoteColumn #'force-hshift = #0 2 + \once \override NoteColumn #'force-hshift = #0.5 des2 + } + >> | + 1 | + } + @end lilypond + + + @node Beispiele aus dem Leben + @subsection Beispiele aus dem Leben + @translationof Real music example + + Das Kapitel zu Optimierungen soll mit einem komplizierten Beispiel + beendet werden, in dem verschiedene Optimierungen vorgenommen + werden müssen, bis das Ergebnis gut ausssieht. Das Beispiel wurde + ganz bewusst gewählt um die Benutzung der Notationsreferenz + zu zeigen, wenn ungewöhnliche Notationsprobleme gelöst werden + müssen. Es ist nicht repräsentativ für normale Notationsprojekte, + lassen Sie sich also nicht durch dieses Beispiel entmutigen! Zum + Glück sind Probleme wie die hier gezeigten nicht sehr häufig. + + Das Beispiel stammt aus Chopins Premiére Ballade, Op. 23, Takte + 6--9, der Übergang vom Lento der Einleitung zum Moderato. + Hier zunächst der Satz, wie er aussehen soll, allerdings ohne + Dynamik, Fingersatz und Pedalbezeichnung, um das Beispiel nicht + zu kompliziert zu machen. + + @c This example should not be indexed + @lilypond[quote,ragged-right] + rhMusic = \relative c'' { + r2 + c4.\( g8 | + \once \override Tie #'staff-position = #3.5 + bes1~ | + \bar "||" + \time 6/4 + \mergeDifferentlyHeadedOn + \mergeDifferentlyDottedOn + bes2.^\markup {\bold "Moderato"} r8 + << + {c,8[ d fis bes a] | } + \\ + % Reposition the c2 to the right of the merged note + {c,8~ \once \override NoteColumn #'force-hshift = #1.0 + % Move the c2 out of the main note column so the merge will work + \shiftOnn c2} + \\ + % Stem on the d2 must be down to permit merging + {s8 \stemDown \once \override Stem #'transparent = ##t d2} + \\ + {s4 fis4.} + >> + \mergeDifferentlyHeadedOff + \mergeDifferentlyDottedOff + g2.\) + } + + lhMusic = \relative c' { + r2 2( | + 1)\arpeggio | + r2. d,,4 r4 r | + r4 + } + + \score { + \new PianoStaff << + \new Staff = "RH" << + \key g \minor + \rhMusic + >> + \new Staff = "LH" << + \key g \minor + \clef "bass" + \lhMusic + >> + >> + } + @end lilypond + + Die erste Überlegung ist, dass das System für die rechte Hand + im dritten Takt vier Stimmen braucht. Das sind die fünf + Achtelnoten mit Balken, das übergebundene C, die Halbe D, die + mit der Achtel D verschmolzen ist, und die punktierte Viertel + Fis, die auch mit einer Achtelnote verschmolzen ist. Alles + andere ist eine einzige Stimme, es ist also am einfachsten, die + Stimmen nur zeitweise zu erstellen, wenn sie auftreten. Wenn + Sie vergessen haben, wie man das anstellt, schauen Sie sich + nochmal den Abschnitt @ref{Ich höre Stimmen} an. Wir + wollen anfange, indem wir die Noten in zwei Variablen + notieren und dann die Systemstruktur in einer + @code{\score}-Umgebung erstellen. Das ist, was LilyPond + erstellt: + + @lilypond[quote,verbatim,ragged-right] + rhMusic = \relative c'' { + r2 c4. g8 | + bes1~ | + \time 6/4 + bes2. r8 + % Start polyphonic section of four voices + << + {c,8 d fis bes a | } + \\ + {c,8~ c2 | } + \\ + {s8 d2 | } + \\ + {s4 fis4. | } + >> + g2. + } + + lhMusic = \relative c' { + r2 2 | + 1 | + r2. d,,4 r4 r | + r4 + } + + \score { + \new PianoStaff << + \new Staff = "RH" << + \key g \minor + \rhMusic + >> + \new Staff = "LH" << + \key g \minor + \clef "bass" + \lhMusic + >> + >> + } + @end lilypond + + Alle Noten sind richtig, aber die Positionierung sehr + verbesserungsbedürftig. Der Bindebogen stößt mit + der veränderten Taktart zusammen, die Balkung im + dritten Takt ist falsch, die Noten werden nicht + verschmolzen und einige Notationselemente fehlen ganz. + Behandeln wir zunächst die einfacheren Dinge. Der + Balken kann durch eine manuelle Begrenzung einfach + korrigiert werden, und auch der Legatobogen der linken + Hand und der Phrasierungsbogen der rechten Hand + sind schnell gesetzt, denn sie wurden schon in der + Übung erklärt. Damit haben wir folgendes Notenbild: + + @lilypond[quote,verbatim,ragged-right] + rhMusic = \relative c'' { + r2 c4.\( g8 | + bes1~ | + \time 6/4 + bes2. r8 + % Start polyphonic section of four voices + << + {c,8[ d fis bes a] | } + \\ + {c,8~ c2 | } + \\ + {s8 d2 | } + \\ + {s4 fis4. | } + >> + g2.\) + } + + lhMusic = \relative c' { + r2 2( | + 1) | + r2. d,,4 r4 r | + r4 + } + + \score { + \new PianoStaff << + \new Staff = "RH" << + \key g \minor + \rhMusic + >> + \new Staff = "LH" << + \key g \minor + \clef "bass" + \lhMusic + >> + >> + } + @end lilypond + + Der erste Takt stimmt jetzt schon. Der zweite Takt enthält ein + Arpeggio und wird mit einer doppelten Taktlinie beschlossen. + Wie können wir diese notieren, denn sie sind im Handbuch zum + Lernen nicht vorgekommen? Hier brauchen wir jetzt die + Notationsreferenz. Ein Blick in den Index zeigt uns die + Einträge für @qq{Arpeggio} und @qq{Taktlinien}: ein + Arpeggio also erstellt man mit dem Befehl @code{\arpeggio} + hinter einem Akkord und eine doppelte Taktlinie wird mit dem + Befehl @code{\bar "||"} erstellt. Das ist einfach. Als nächstes + muss der Zusammenstoß des Bindebogens mit der Taktartbezeichnung + gelöst werden. Das geht am besten, indem wir den Bogen nach + oben verschieben. Wie man Objekte verschiebt wurde schon + behandelt in @ref{Verschieben von Objekten}, wo stand, dass Objekte + die + relativ zum System positioniert werden, verschoben werden + können, indem ihre @code{staff-position}-Eigenschaft + geändert wird, die in halben Notenlienienabständen relativ + zur Mittellinie angegeben wird. Dieser @code{\override}-Befehl + also, direkt vor die erste übergebundene Note gestellt, verschiebt + den Bindebogen (@code{tie}) 3,5 halbe Notenlinienabstände + über die Mittellinie: + + @code{\once \override Tie #'staff-position = #3.5} + + Damit ist auch der zweite Takt vollständig: + + @lilypond[quote,verbatim,ragged-right] + rhMusic = \relative c'' { + r2 c4.\( g8 | + \once \override Tie #'staff-position = #3.5 + bes1~ | + \bar "||" + \time 6/4 + bes2. r8 + % Start polyphonic section of four voices + << + {c,8[ d fis bes a] | } + \\ + {c,8~ c2 | } + \\ + {s8 d2 | } + \\ + {s4 fis4. | } + >> + g2.\) + } + + lhMusic = \relative c' { + r2 2( | + 1)\arpeggio | + r2. d,,4 r4 r | + r4 + } + + \score { + \new PianoStaff << + \new Staff = "RH" << + \key g \minor + \rhMusic + >> + \new Staff = "LH" << + \key g \minor + \clef "bass" + \lhMusic + >> + >> + } + @end lilypond + + In Takt drei beginnt der Moderato-Abschnitt. In der + Übung wurde behandelt, wie man fetten Text mit dem + @code{\markup}-Befehl eingibt, es ist also einfach, das + @qq{Moderato} hinzuzufügen. Wie aber werden Noten + verschmolzen? Hier nehmen wir wieder die Notationsreferenz + zu Hilfe. Die Suche nach @qq{Verschmelzen} (engl. merge) + im Index führt uns zu den Befehlen um Noten mit + unterschiedlichen Köpfen und unterschiedlichen Punkten + zu verschmelzen in @ruser{Auflösung von Zusammenstößen}. In unserem + Beispiel müssen sowohl unterschiedliche Köpfe also auch + unterschiedliche Punktierung verschmolzen werden, wir + brauchen also die Befehle + + @example + \mergeDifferentlyHeadedOn + \mergeDifferentlyDottedOn + @end example + + @noindent + aus der Notationsreferenz, die wir an den Beginn unseres + Abschnittes stellen und + + @example + \mergeDifferentlyHeadedOff + \mergeDifferentlyDottedOff + @end example + + @noindent + um das Verhalten wieder auszuschalten. Das sieht so aus: + + @cindex Bindebogen, Beispiel zur Veränderung + @cindex staff-position-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,ragged-right] + rhMusic = \relative c'' { + r2 c4.\( g8 | + \once \override Tie #'staff-position = #3.5 + bes1~ | + \bar "||" + \time 6/4 + bes2.^\markup {\bold "Moderato"} r8 + \mergeDifferentlyHeadedOn + \mergeDifferentlyDottedOn + % Start polyphonic section of four voices + << + {c,8[ d fis bes a] | } + \\ + {c,8~ c2 | } + \\ + {s8 d2 | } + \\ + {s4 fis4. | } + >> + \mergeDifferentlyHeadedOff + \mergeDifferentlyDottedOff + g2.\) + } + + lhMusic = \relative c' { + r2 2( | + 1)\arpeggio | + r2. d,,4 r4 r | + r4 + } + + \score { + \new PianoStaff << + \new Staff = "RH" << + \key g \minor + \rhMusic + >> + \new Staff = "LH" << + \key g \minor + \clef "bass" + \lhMusic + >> + >> + } + @end lilypond + + Mit diesen Veränderungen wurden die beiden Fis-Noten + verschmolzen, aber nicht die zwei Ds. Warum nicht? Die + Antwort befindet sich im gleicher Abschnitt der Notationsreferenz: + Noten, die verschmolzen werden, müssen Hälse in entgegengesetzte + Richtungen aufweisen und zwei Noten können nicht verschmolzen + werden, wenn eine dritte Noten in der gleichen Kolumne + stört. In unserem Fall weisen beide Hälse nach oben und es + befindet sich zur gleichen Zeit auch noch eine dritte Note, das C. + Wie die Richtung von Hälsen geändert wird, wissen wir schon: + mit @code{\stemDown}, und in der Notationsreferenz findet + sich auch Information, wie das C verschoben werden kann: mit + dem @code{\shift}-Befehl. Aber welcher von ihnen? Das C + befindet sich in der zweiten Stimme, die @qq{shift off} hat, + die zwei Ds sind in den Stimmen eins und drei, die @qq{shift + off} bzw. @qq{shift on} haben. Das C muss also noch eine + Stufe weiter verschoben werden mit @code{\shiftOnn}, damit + es die Verschmelzung der Ds nicht stört. Das sieht jetzt so + aus: + + @lilypond[quote,verbatim,ragged-right] + rhMusic = \relative c'' { + r2 c4.\( g8 | + \once \override Tie #'staff-position = #3.5 + bes1~ | + \bar "||" + \time 6/4 + bes2.^\markup {\bold "Moderato"} r8 + \mergeDifferentlyHeadedOn + \mergeDifferentlyDottedOn + % Start polyphonic section of four voices + << + {c,8[ d fis bes a] | } + \\ + % Move the c2 out of the main note column so the merge will work + {c,8~ \shiftOnn c2 | } + \\ + % Stem on the d2 must be down to permit merging + {s8 \stemDown d2 | } + \\ + {s4 fis4. | } + >> + \mergeDifferentlyHeadedOff + \mergeDifferentlyDottedOff + g2.\) + } + + lhMusic = \relative c' { + r2 2( | + 1)\arpeggio | + r2. d,,4 r4 r | + r4 + } + + \score { + \new PianoStaff << + \new Staff = "RH" << + \key g \minor + \rhMusic + >> + \new Staff = "LH" << + \key g \minor + \clef "bass" + \lhMusic + >> + >> + } + @end lilypond + + Fast schon geschafft. Nur noch ein Problem ist übrig: Der Hals nach + unten des verschmolzenen sollte nicht da sein, und das C sähe + besser auf der rechten Seite des Ds aus. Beides können wir mit den + gelernten Optimierungsmethoden erreichen. Den Hals machen + wir durchsichtig und das C verschieben wir mit der + @code{force-hshift}-Eigenschaft. Hier ist das Endergebnis: + + @cindex Notenkolumne, Beispiel zur Veränderung + @cindex force-hshift-Eigenschaft, Beispiel + @cindex Hals, Beispiel zur Veränderung + @cindex Notenhals, Beispiel zur Veränderung + @cindex transparent-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,ragged-right] + rhMusic = \relative c'' { + r2 + c4.\( g8 | + \once \override Tie #'staff-position = #3.5 + bes1~ | + \bar "||" + \time 6/4 + bes2.^\markup {\bold "Moderato"} r8 + \mergeDifferentlyHeadedOn + \mergeDifferentlyDottedOn + << + {c,8[ d fis bes a] | } + \\ + % Reposition the c2 to the right of the merged note + {c,8~ \once \override NoteColumn #'force-hshift = #1.0 + % Move the c2 out of the main note column so the merge will work + \shiftOnn c2} + \\ + % Stem on the d2 must be down to permit merging + {s8 \stemDown \once \override Stem #'transparent = ##t d2} + \\ + {s4 fis4.} + >> + \mergeDifferentlyHeadedOff + \mergeDifferentlyDottedOff + g2.\) + } + + lhMusic = \relative c' { + r2 2( | + 1)\arpeggio | + r2. d,,4 r4 r | + r4 + } + + \score { + \new PianoStaff << + \new Staff = "RH" << + \key g \minor + \rhMusic + >> + \new Staff = "LH" << + \key g \minor + \clef "bass" + \lhMusic + >> + >> + } + @end lilypond + + + @node Weitere Optimierungen + @section Weitere Optimierungen + @translationof Further tweaking + + @menu + * Andere Benutzung von Optimierungen:: + * Variablen für Optimierungen einsetzen:: + * Mehr Information:: + * Vermeiden von Optimierungen durch langsamere Übersetzung:: + * Fortgeschrittene Optimierungen mit Scheme:: + @end menu + + @node Andere Benutzung von Optimierungen + @subsection Andere Benutzung von Optimierungen + @translationof Other uses for tweaks + + @cindex Transparente Objekte + @cindex Entfernen von Objekten + @cindex Verstecken von Objekten + @cindex Unsichtbare Objekte + @cindex transparent-Eigenschaft, Benutzung + @cindex Objekte unsichtbar machen + @cindex Objekte entfernen + @cindex Objekte verstecken + @cindex Noten zwischen Stimmen überbinden + @cindex Überbinden von Noten zwischen Stimmen + + @subheading Noten zwischen unterschiedlichen Stimmen überbinden + + Das nächste Beispiel zeigt, wie man Noten von verschiedenen + Stimmen miteinander verknüpfen kann, indem man Bindebögen + für Überbindungen benutzt. Normalerweise können nur zwei + Noten der gleichen Stimme übergebunden werden. Wenn + man zwei Stimmen benutzt, wobei die überbundenen Noten + sich in der selben befinden, + + @lilypond[quote,fragment,relative=2] + << { b8~ b8\noBeam } + \\ { b[ g8] } + >> + @end lilypond + + @noindent + und dann den ersten Hals nach oben unsichtbar macht, + sieht es so aus, als ob die Überbindung zwischen + den Stimmen stattfindet: + + @cindex Hals, Beispiel zur Veränderung + @cindex Notenhals, Beispiel zur Veränderung + @cindex transparent-Eigenschaft, Beispiel + + @lilypond[quote,fragment,relative=2,verbatim] + << + { + \once \override Stem #'transparent = ##t + b8~ b8\noBeam + } + \\ + { b[ g8] } + >> + @end lilypond + + Um sicherzugehen, dass der unsichtbare Hals den Bindebogen + nicht zu sehr verkleinert, kann er verlängert werden, indem + seine Länge (@code{length}) auf den Wert @code{8} + gesetzt wird: + + @lilypond[quote,fragment,relative=2,verbatim] + << + { + \once \override Stem #'transparent = ##t + \once \override Stem #'length = #8 + b8~ b8\noBeam + } + \\ + { b[ g8] } + >> + @end lilypond + + + @subheading Eine Fermate in MIDI simulieren + + @cindex stencil-Eigenschaft, Benutzung + @cindex Fermate, Benutzung in MIDI + @cindex MIDI: Fermate erstellen + + Für Objekte außerhalb des Notensystems ist es normalerweise + besser, die @code{stencil}-Eigenschaft anstelle der + @code{transparent}-Eigenschaft zu verändern, wenn man + sie vom fertigen Notensatz entfernen will. Indem die + @code{stencil}-Eigenschaft auf falsch (@code{#f}) gesetzt + wird, wird das entsprechende Objekt vollständig entfernt. + Das bedeutet, dass es die Positionierung der anderen Objekte + nicht beeinflusst. + + Auf diese Art kann etwa das Tempo geändert werden, damit + in der MIDI-Ausgabe eine Fermate zu hören ist, ohne dass + im Notensatz etwas von diesen Tempoänderungen zu sehen + ist. Die Metronombezeichnung soll auch nicht die Position + von Text an der gleichen Stelle oder die Abstände zwischen + zwei Systemen beeinflussen. Darum ist es am besten, + @code{stencil} auf @code{#f} zu setzen. Im Beispiel wird + der Unterschied zwischen einem unsichtbaren Objekt und + einem entfernten Objekt gezeigt: + + @cindex Metronom-Bezeichnung, Beispiel zur Veränderung + @cindex transparent-Eigenschaft, Beispiel + + @lilypond[quote,verbatim,ragged-right] + \score { + \relative c'' { + % Visible tempo marking + \tempo 4=120 + a4 a a + \once \override Score.MetronomeMark #'transparent = ##t + % Invisible tempo marking to lengthen fermata in MIDI + \tempo 4=80 + a\fermata + % New tempo for next section + \tempo 4=100 + a a a a + } + \layout { } + \midi { } + } + @end lilypond + + @lilypond[quote,verbatim,ragged-right] + \score { + \relative c'' { + % Visible tempo marking + \tempo 4=120 + a4 a a + \once \override Score.MetronomeMark #'stencil = ##f + % Invisible tempo marking to lengthen fermata in MIDI + \tempo 4=80 + a\fermata + % New tempo for next section + \tempo 4=100 + a a a a + } + \layout { } + \midi { } + } + @end lilypond + + @noindent + Mit beiden Methoden wird die Tempobezeichnung entfernt, mit + der die Fermate verlängert wird, und beide beeinflussen die + MIDI-Ausgabe wie gewünscht. Die unsichtbare Metronombezeichnung + schiebt aber die folgende Bezeichnung in die Höhe, während + das im zweiten Beispiel, in dem der @code{stencil} entfernt + wurde, nicht passiert. + + + @node Variablen für Optimierungen einsetzen + @subsection Variablen für Optimierungen einsetzen + @translationof Using variables for tweaks + + @cindex Variablen, Benutzung zur Optimierung + @cindex Optimierung mit Variablen + + @code{\override}-Befehle sind oft lang und mühsam zu + tippen, und sie müssen immer absolut richtig sein. Wenn + derselbe Befehl mehrere Male benutzt werden muss, lohnt + es sich oft schon, eine Variable zu definieren, in der er + sich befindet. + + Als Beispiel sollen einige Worte im + Gesangstext fett und kursiv hervorgehoben werden. + Die Befehle @code{\italic} und @code{\bold} funktionieren + im Gesangstext-Kontext nur, wenn sie gleichzeitig mit den Wörtern, + auf die sie angewendet werden sollen, zusätzlich + in eine @code{\markup}-Umgebung eingeschlossen + werden. Durch diese Einbettung können einzelne Wörter nicht + einfach zu einer Variable umgeformt werden. Als + Alternative versuchen wir, einen Befehl mit + @code{\override} und @code{\revert} zu konstruieren. + + @example + @code{\override Lyrics . LyricText #'font-shape = #'italic} + @code{\override Lyrics . LyricText #'font-series = #'bold} + + @code{\revert Lyrics . LyricText #'font-shape} + @code{\revert Lyrics . LyricText #'font-series} + @end example + + Das wäre natürlich noch viel mühsamer, wenn viele Wörter eine + Hervorhebung benötigen. Anstelle dieser Befehlsketten @emph{können} + wir jedoch zwei Variablen definieren. Mit ihnen und dem entsprechenden + Wort in geschweiften Klammern erreichen wir den gewünschten Effekt. + Ein weiterer Vorteil ist, dass in diesem Fall die Leerzeichn um die + Punkte herum nicht benötigt werden, weil sie nicht innerhalb des + @code{lyricmode}-Kontextes interpretiert werden. Hier ein Beispiel; + die Bezeichnungen können natürlich auch kürzer sein, + um noch weniger schreiben zu müssen: + + @cindex LyricText, Beispiel zur Veränderung + @cindex Gesangstext, Beispiel zur Veränderung + @cindex font-shape-Eigenschaft, Beispiel + @cindex font-series-Eigenschaft, Beispiel + + @lilypond[quote,verbatim] + emphasize = { + \override Lyrics.LyricText #'font-shape = #'italic + \override Lyrics.LyricText #'font-series = #'bold + } + normal = { + \revert Lyrics.LyricText #'font-shape + \revert Lyrics.LyricText #'font-series + } + + global = { \time 4/4 \partial 4 \key c \major} + SopranoMusic = \relative c' { c4 | e4. e8 g4 g | a a g } + AltoMusic = \relative c' { c4 | c4. c8 e4 e | f f e } + TenorMusic = \relative c { e4 | g4. g8 c4. b8 | a8 b c d e4 } + BassMusic = \relative c { c4 | c4. c8 c4 c | f8 g a b c4 } + VerseOne = \lyrics { E -- | ter -- nal \emphasize Fa -- ther, \normal | strong to save, } + VerseTwo = \lyricmode { O | \emphasize Christ, \normal whose voice the | wa -- ters heard, } + VerseThree = \lyricmode { O | \emphasize Ho -- ly Spi -- rit, \normal | who didst brood } + VerseFour = \lyricmode { O | \emphasize Tri -- ni -- ty \normal of | love and pow'r } + + \score { + \new ChoirStaff << + \new Staff << + \clef "treble" + \new Voice = "Soprano" { \voiceOne \global \SopranoMusic } + \new Voice = "Alto" { \voiceTwo \AltoMusic } + \new Lyrics \lyricsto "Soprano" { \VerseOne } + \new Lyrics \lyricsto "Soprano" { \VerseTwo } + \new Lyrics \lyricsto "Soprano" { \VerseThree } + \new Lyrics \lyricsto "Soprano" { \VerseFour } + >> + \new Staff << + \clef "bass" + \new Voice = "Tenor" { \voiceOne \TenorMusic } + \new Voice = "Bass" { \voiceTwo \BassMusic } + >> + >> + } + @end lilypond + + + @node Mehr Information + @subsection Mehr Information + @translationof Other sources of information + + Die Programmreferenz enthält sehr viel Information über LilyPond, aber + noch mehr Information findet sich in den internen + LilyPond-Dateien. Um sie erforschen zu können, müssen Sie erst + das richtige Verzeichnis auf Ihrem System finden. Die Position + hängt a) davon ab, ob Ihre LilyPond-Installation mit der vorkompilierten + Version von der LilyPond-Internetseite vorgenommen wurde oder Sie + die Version durch Ihren Paketmanager installiert haben (also + z. B. in einer Linux-Distribution oder unter fink oder cygwin + installiert), und b) auf welchem Betriebssystem Sie das Programm + benutzen: + + @strong{Von lilypond.org heruntergeladen} + + @itemize @bullet + @item Linux + + Wechseln Sie in das Verzeichnis + @file{@var{INSTALL_VERZ}/lilypond/usr/share/lilypond/current/} + + @item MacOS X + + Wechseln Sie in das Verzeichnis + @file{@var{INSTALL_VERZ}/LilyPond.app/Contents/Resources/share/lilypond/current/} + indem Sie entweder mit dem Befehl @code{cd} vom Terminal aus + in das Verzeichnis wechseln, oder mit Control-Klick auf das + LilyPond-Programmsymbol gehen und @qq{Show Package Contents} + auswählen. + + @item Windows + + Wechseln Sie mit dem Windows Explorer ins Verzeichnis + @file{@var{INSTALL_VERZ}/LilyPond/usr/share/lilypond/current/} + + @end itemize + + @strong{Mit einem Paket-Manager installiert oder selber aus + den Quellen kompiliert} + + Wechseln Sie in das Verzeichnis + @file{@var{PREFIX}/share/lilypond/@var{X.Y.Z}/}, wobei + @var{PREFIX} bei Ihrem Paket-Manager oder dem + @code{configure}-Skript gesetzt wird, und @var{X.Y.Z} + die LilyPond-Versionsnummer. + + @smallspace + + In diesem Ordner sind die zwei interessanten Unterordner: + + @itemize + @item @file{ly/} - beinhaltet Dateien im LilyPond-Format + @item @file{scm/} - beinhaltet Dateien im Scheme-Format + @end itemize + + Schauen wir uns zuerst einige Dateien in @file{ly/} an. + Öffnen Sie @file{ly/property-init.ly} in einem Texteditor. + Der, den Sie normalerweise für @code{.ly}-Dateien benutzen, + genügt. Diese Datei enthält die Definitionen aller vordefinierten + Befehle für LilyPond, wie etwa @code{\stemUp} und + @code{\slurDotted}. Sie können sehen, dass es sich um + nichts mehr handelt als Definitionen von Variablen, die eine + oder mehrere @code{\override}-Befehle enthalten. Der + Befehl @code{/tieDotted} etwa wird folgendermaßen definiert: + + @example + tieDotted = @{ + \override Tie #'dash-period = #0.75 + \override Tie #'dash-fraction = #0.1 + @} + @end example + + Wenn Sie diese Voreinstellungen der vordefinierten Befehl nicht + mögen, können Sie sie ganz einfach umdefinieren, genauso wie + jede andere Variable auch, indem Sie sie an den Anfang Ihrer + Quelldatei schreiben. + + Hier sind die wichtisgsten Dateien, die sich im Ordner + @file{ly/} befinden: + + @multitable @columnfractions .4 .6 + @headitem Dateiname + @tab Inhalt + @item @file{ly/engraver-init.ly} + @tab Definitionen von Engraver-Kontexten + @item @file{ly/paper-defaults-init.ly} + @tab Spezifikationen von Voreinstellungen für Papiermaße + @item @file{ly/performer-init.ly} + @tab Definitionen von Performer-Kontexten + @item @file{ly/property-init.ly} + @tab Definitionen aller vordefinierten Befehle + @item @file{ly/spanner-init.ly} + @tab Definitionen aller vordefinierten Strecker-Befehle + @end multitable + + Andere Einstellungen (wie die Definitionen von Beschriftungsbefehlen) + sind in @code{.scm}-(Scheme)-Dateien gespeichert. Die + Scheme-Programmiersprache wird benutzt, um eine + programmierbare Schnittstelle zu den internen Operationen von + LilyPond zu haben. Eine weitere Erklärung dieser Dateien ist + im Moment außerhalb des Rahmens dieses Handbuchs, denn + sie erfordern einige Kenntnis der Scheme-Sprache. Die Warnung + ist hier angebracht, dass des ein gutes technisches Verständnis + oder sehr viel Zeit braucht, um Scheme und diese + Dateien zu verstehen (siehe auch @ref{Scheme-Übung}). + + Wenn Sie sich mit Scheme auskennen, sind hier mögliche + interessante Dateien: + + @multitable @columnfractions .4 .6 + @headitem Dateiname + @tab Inhalt + @item @file{scm/auto-beam.scm} + @tab Sub-Balken-Voreinstellungen + @item @file{scm/define-grobs.scm} + @tab Voreinstellungen für Grob-Eigenschaften + @item @file{scm/define-markup-commands.scm} + @tab Definition aller Markup-Beschriftungsbefehle + @item @file{scm/midi.scm} + @tab Voreinstellung für die MIDI-Ausgabe + @item @file{scm/output-lib.scm} + @tab Einstellungen mit Einfluss auf die Darstellung von Bunddiagrammen, Farben, Versetzungszeichen, Taktlinien usw. + @item @file{scm/parser-clef.scm} + @tab Definitionen der unterstützten Schlüssel + @item @file{scm/script.scm} + @tab Voreinstellungen for Artikulationszeichen + @end multitable + + + @node Vermeiden von Optimierungen durch langsamere Übersetzung + @subsection Vermeiden von Optimierungen durch langsamere Übersetzung + @translationof Avoiding tweaks with slower processing + + LilyPond kann einige zusätzliche Tests durchführen, während + die Noten gesetzt werden. Dadurch braucht das Programm länger, + um den Notensatz zu produzieren, aber üblicherweise werden + weniger nachträgliche Anpassungen nötig sein. Wenn eine + Textsilbe oder eine Beschriftung aus dem Rand der Partitur + ragt, wird durch diese Tests die Zeile gerade so weit komprimiert, + dass sie sich innerhalb der Ränder befindet. + + @example + \new Score \with @{ + % Um sicher zu gehen, dass Texte und Liedtext + % innerhalb der Papierränder bleiben + \override PaperColumn #'keep-inside-line = ##t + \override NonMusicalPaperColumn #'keep-inside-line = ##t + @} @{ + ... + @} + @end example + + + @node Fortgeschrittene Optimierungen mit Scheme + @subsection Fortgeschrittene Optimierungen mit Scheme + @translationof Advanced tweaks with Scheme + + Auch wenn viele Sachen mit @code{\override} und @code{\tweak} + möglich sind, gibt es eine sehr viel mächtigere Möglichkeit, die + Arbeitsweise von LilyPond mit Hilfe der programmierbaren Schnittstelle + zu beeinflussen. Code, der in der Scheme-Programmiersprache + geschrieben ist, kann direkt in die interne Satzmaschine von LilyPond + eingefügt werden. Natürlich brauchen Sie dazu wenigstens ein + grundlegendes Verständnis von Scheme. Eine Einleitung finden + Sie in der @ref{Scheme-Übung}. + + Zur Illustration der vielen Möglichkeiten soll gezeigt werden, dass eine + Eigenschaft nicht nur auf eine Konstante, sondern auch auf eine + Scheme-Prozedur gesetzt werden kann, die dann jedes Mal + aufgerufen wird, wenn die Eigenschaft von LilyPond benutzt + wird. Die Eigenschaft kann damit dynamisch auf einen Wert + gesetzt werden, der durch die Prozedur jedes Mal neu bestimmt + wird. In diesem Beispiel wird die Farbe der Notenköpfe entsprechend + zu ihrer Position innerhalb der Tonleiter gesetzt. + + @cindex x11-Farben, Beispiel zur Benutzung + @cindex Notenkopf, Beispiel zur Veränderung + @cindex Farb-Eigenschaft, in Scheme-Prozedur gesetzt + + @lilypond[quote,verbatim,ragged-right] + #(define (color-notehead grob) + "Color the notehead according to its position on the staff." + (let ((mod-position (modulo (ly:grob-property grob 'staff-position) 7))) + (case mod-position + ;; Return rainbow colors + ((1) (x11-color 'red )) ; for C + ((2) (x11-color 'orange )) ; for D + ((3) (x11-color 'yellow )) ; for E + ((4) (x11-color 'green )) ; for F + ((5) (x11-color 'blue )) ; for G + ((6) (x11-color 'purple )) ; for A + ((0) (x11-color 'violet )) ; for B + ) + ) + ) + + \relative c' { + % Arrange to obtain color from color-notehead procedure + \override NoteHead #'color = #color-notehead + c2 c' | + b4 g8 a b4 c | + c,2 a' | + g1 | + } + \addlyrics { + Some -- where o -- ver the Rain -- bow, way up high, + } + @end lilypond + + Weiter Beispiele, die die Benutzung dieser programmierbaren + Schnittstelle zeigen, finden sich in @ref{Optimierungen mit Scheme}. diff --cc Documentation/de/macros.itexi index 0000000000,7fa259656a..dfd9e8ea8a mode 000000,100644..100644 --- a/Documentation/de/macros.itexi +++ b/Documentation/de/macros.itexi @@@ -1,0 -1,366 +1,338 @@@ + @c -*- coding: utf-8; mode: texinfo; -*- + @ignore + Translation of GIT committish: 01361d46dc9d514a79683d003eeea5f4fbf2b746 + + When revising a translation, copy the HEAD committish of the + version that you are working on. See TRANSLATION for details. + @end ignore + + + @include version.itexi + @include common-macros.itexi + + + @c ***** Displaying text ***** + + @c To get decent quotes in ,foo' and ,,foo''. + @c These need to be split up so that "@qq{foo}." looks nice. :( + + @macro q{TEXT} + @quotesinglbase{}\TEXT\@quoteleft{} + @end macro + + @macro qq{TEXT} + @quotedblbase{}\TEXT\@quotedblleft{} + @end macro + + + @ifhtml + + @macro warning{TEXT} + @cartouche + @b{Achtung:} \TEXT\ + @end cartouche + @end macro + + @end ifhtml + + @ifnothtml + + @macro warning{TEXT} + @quotation + @quotation + @cartouche + @b{Achtung:} \TEXT\ + @end cartouche + @end quotation + @end quotation + @end macro + + @end ifnothtml + + + @c ***** Headings in a doc subsection ***** + + @c Don't insert an empty line after @predefined! Right now + @c it doesn't matter, but a future implementation will probably + @c add some code which needs this restriction. + + @macro predefined + @noindent + @subsubheading Vordefinierte Befehle + @end macro + + @c The next macro is a dummy currently since texinfo doesn't + @c provide a real ragged-right environment yet. + @c + @c Due to a bug in texi2html (texi2html.pl CVS versions <= 1.245) + @c the macro must not be empty. + + @macro endpredefined + @c + @end macro + + + @macro snippets + @noindent + @subsubheading Ausgewählte Schnipsel + @end macro + + -@c obsolete, remove when translation is fully updated -@macro commonprop -@noindent -@subsubheading Übliche Veränderungen der Einstellungen -@end macro - + + @c Don't insert an empty line after @seealso! Otherwise we get + @c unwanted extra vertical space in the PDF output. + + @macro seealso + @noindent + @subsubheading Siehe auch + @indent + @end macro + + + @macro knownissues + @noindent + @subsubheading Bekannte Probleme und Warnungen + @end macro + + + + @c ***** Links and references ***** + -@c obsolete -@c usage: @lsr{ancient,custodes.ly} -@macro lsr{DIR,TEXT} -@ifhtml -@uref{source/input/lsr/\DIR\/collated-files.html#\TEXT\,@file{\DIR\/\TEXT\}} -@end ifhtml -@ifnothtml -@file{\DIR\/\TEXT\} -@end ifnothtml -@end macro - -@c don't update until this macro is correctly set up in English docs -@macro lsrdir{DIR} -@ifhtml -@uref{source/input/lsr/\DIR\/collated-files.html,@file{\DIR\}/} -@end ifhtml -@ifnothtml -@file{\DIR\} -@end ifnothtml -@end macro - - + @c Definitions for references: + @c + @c @rglos + @c @rlearning + @c @ruser + @c @rprogram + @c @rlsr + @c @rinternals + @c + @c All these also have a @...named version which allows to specify the + @c displayed text for the reference as second argument. + @c + @c ***** HTML + bigpage is a special case (other manual names); all other + @c formats are treated similarly. + + + @c *** not TeX *** + + @ifnottex + + @c ** bigpage ** + + @ifset bigpage + + @macro rglos{TEXT} + @vindex \TEXT\ + @ref{\TEXT\,,,music-glossary-big-page,Glossar} + @end macro + + @macro rglosnamed{TEXT,DISPLAY} + @vindex \TEXT\ + @ref{\TEXT\,,\DISPLAY\,music-glossary-big-page,Glossar} + @end macro + + @macro rlearning{TEXT} + @vindex \TEXT\ + @ref{\TEXT\,,,learning-big-page,Handbuch zum Lernen} + @end macro + + @macro rlearningnamed{TEXT,DISPLAY} + @vindex \TEXT\ + @ref{\TEXT\,,\DISPLAY\,learning-big-page,Handbuch zum Lernen} + @end macro + + @macro ruser{TEXT} + @vindex \TEXT\ + @ref{\TEXT\,,,notation-big-page,Notationsreferenz} + @end macro + + @macro rusernamed{TEXT,DISPLAY} + @vindex \TEXT\ + @ref{\TEXT\,,\DISPLAY\,notation-big-page,Notationsreferenz} + @end macro + + @macro rprogram{TEXT} + @vindex \TEXT\ + @ref{\TEXT\,,,application-big-page,Anwendungsbenutzung} + @end macro + + @macro rprogramnamed{TEXT,DISPLAY} + @vindex \TEXT\ + @ref{\TEXT\,,\DISPLAY\,application-big-page,Anwendungsbenutzung} + @end macro + + @macro rlsr{TEXT} + @ref{\TEXT\,,,snippets-big-page,Schnipsel} + @end macro + + @macro rlsrnamed{TEXT,DISPLAY} + @ref{\TEXT\,,\DISPLAY\,snippets-big-page,Schnipsel} + @end macro + + @macro rinternals{TEXT} + @vindex \TEXT\ + @ref{\TEXT\,,,internals-big-page,Referenz der Interna} + @end macro + + @macro rinternalsnamed{TEXT,DISPLAY} + @vindex \TEXT\ + @ref{\TEXT\,,\DISPLAY\,internals-big-page,Referenz der Interna} + @end macro + + @end ifset + + + @c ** not bigpage ** + + @ifclear bigpage + + @macro rglos{TEXT} + @vindex \TEXT\ + @ref{\TEXT\,,,music-glossary,Glossar} + @end macro + + @macro rglosnamed{TEXT,DISPLAY} + @vindex \TEXT\ + @ref{\TEXT\,,\DISPLAY\,music-glossary,Glossar} + @end macro + + @macro rlearning{TEXT} + @vindex \TEXT\ + @ref{\TEXT\,,,learning,Handbuch zum Lernen} + @end macro + + @macro rlearningnamed{TEXT,DISPLAY} + @vindex \TEXT\ + @ref{\TEXT\,,\DISPLAY\,learning,Handbuch zum Lernen} + @end macro + + @macro ruser{TEXT} + @vindex \TEXT\ + @ref{\TEXT\,,,notation,Notationsreferenz} + @end macro + + @macro rusernamed{TEXT,DISPLAY} + @vindex \TEXT\ + @ref{\TEXT\,,\DISPLAY\,notation,Notationsreferenz} + @end macro + + @macro rprogram{TEXT} + @vindex \TEXT\ + @ref{\TEXT\,,,application,Anwendungsbenutzung} + @end macro + + @macro rprogramnamed{TEXT,DISPLAY} + @vindex \TEXT\ + @ref{\TEXT\,,\DISPLAY\,application,Anwendungsbenutzung} + @end macro + + @macro rlsr{TEXT} + @ref{\TEXT\,,,snippets,Schnipsel} + @end macro + + @macro rlsrnamed{TEXT,DISPLAY} + @ref{\TEXT\,,\DISPLAY\,snippets,Schnipsel} + @end macro + + @macro rinternals{TEXT} + @vindex \TEXT\ + @ref{\TEXT\,,,internals,Referenz der Interna} + @end macro + + @macro rinternalsnamed{TEXT,DISPLAY} + @vindex \TEXT\ + @ref{\TEXT\,,\DISPLAY\,internals,Referenz der Interna} + @end macro + + @end ifclear + + @end ifnottex + + + @c *** TeX *** + + @iftex + + @c All commands below should work in the middle of the line; + @c we thus must not use @vindex directly since it works only if placed + @c on a line of its own. To overcome this problem, we define a + @c replacement macro using the internal definition of @vindex which + @c delimits arguments in the standard way (i.e., with braces). + + @tex + \gdef\lilyvindex#1{\doind{vr}{\code #1}\ignorespaces} + @end tex + + @macro rglos{TEXT} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,,music-glossary,Glossar} + @end macro + + @macro rglosnamed{TEXT,DISPLAY} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,\DISPLAY\,music-glossary,Glossar} + @end macro + + @macro rlearning{TEXT} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,,learning.de,Handbuch zum Lernen} + @end macro + + @macro rlearningnamed{TEXT,DISPLAY} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,\DISPLAY\,learning.de,Handbuch zum Lernen} + @end macro + + @macro ruser{TEXT} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,,notation.de,Notationsreferenz} + @end macro + + @macro rusernamed{TEXT,DISPLAY} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,\DISPLAY\,notation.de,Notationsreferenz} + @end macro + + @macro rprogram{TEXT} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,,application.de,Anwendungsbenutzung} + @end macro + + @macro rprogramnamed{TEXT,DISPLAY} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,\DISPLAY\,application.de,Anwendungsbenutzung} + @end macro + + @macro rlsr{TEXT} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,,snippets,Schnipsel} + @end macro + + @macro rlsrnamed{TEXT,DISPLAY} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,\DISPLAY\,snippets,Schnipsel} + @end macro + + @macro rinternals{TEXT} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,,internals,Referenz der Interna} + @end macro + + @macro rinternalsnamed{TEXT,DISPLAY} + @lilyvindex{\TEXT\} + @ref{\TEXT\,,\DISPLAY\,internals,Referenz der Interna} + @end macro + + @end iftex + + + + @c ***** Macros specific to translated docs ***** + + + @macro englishref + Dieser Abschnitt wurde noch nicht übersetzt. Bitte lesen Sie den + Abschnitt im englischen Benutzerhandbuch. + @end macro + diff --cc Documentation/de/notation/input.itely index 0000000000,cf6f1e219c..6d1e7c7af5 mode 000000,100644..100644 --- a/Documentation/de/notation/input.itely +++ b/Documentation/de/notation/input.itely @@@ -1,0 -1,2077 +1,2112 @@@ + @c -*- coding: utf-8; mode: texinfo; documentlanguage: de -*- + + @ignore - Translation of GIT committish: 5131c3292d30cabdf08839daa02a006e4d3c96c5 ++ Translation of GIT committish: 5cf864d550e7148412d594cf336841791bff6f76 + + When revising a translation, copy the HEAD committish of the + version that you are working on. See TRANSLATION for details. + @end ignore + + @c \version "2.12.0" + + @node Allgemeine Eingabe und Ausgabe + @chapter Allgemeine Eingabe und Ausgabe + @translationof General input and output + + Dieses Kapitel erklärt allgemeine Fragen zur Eingabe und Ausgabe von + Notation mit LilyPond und weniger direkte Fragen der Notation. + + @menu + * Eingabestruktur:: + * Titel:: + * Arbeiten an Eingabe-Dateien:: + * Ausgabe kontrollieren:: + * MIDI-Ausgabe:: + @end menu + + + @node Eingabestruktur + @section Eingabestruktur + @translationof Input structure + + Das hauptsächliche Eingabeformat von LilyPond sind Textdateien. + Üblicherweise werden diese Dateien mit der Endung @code{.ly} + versehen. + + @menu + * Struktur einer Partitur:: + * Mehrere Partituren in einem Buch:: + * Die Dateistruktur:: + @end menu + + + @node Struktur einer Partitur + @subsection Struktur einer Partitur + @translationof Structure of a score + + @funindex \score + + Eine @code{\score}-Umgebung muss einen einzelnen musikalischen + Ausdruck beinhalten, der durch geschweifte Klammern begrenzt wird: + + @example + \score @{ + ... + @} + @end example + + @warning{Es darf @strong{nur ein} äußerer musikalischer Ausdruck + in der @code{\score}-Umgebung geschrieben werden, und er @strong{muss} + von geschweiften Klammern umgeben sein.} + + Dieser einzelne musikalische Ausdruck kann beliebige Größe annehmen und + andere musikalische Ausdrücke von beliebiger Komplexität beinhalten. + Alle diese Beispielse sind musikalische Ausdrücke: + + @example + @{ c'4 c' c' c' @} + @end example + + @lilypond[verbatim,quote] + { + { c'4 c' c' c'} + { d'4 d' d' d'} + } + @end lilypond + + @lilypond[verbatim,quote] + << + \new Staff { c'4 c' c' c' } + \new Staff { d'4 d' d' d' } + >> + @end lilypond + + @example + @{ + \new GrandStaff << + \new StaffGroup << + \new Staff @{ \Flöte @} + \new Staff @{ \Oboe @} + >> + \new StaffGroup << + \new Staff @{ \GeigeI @} + \new Staff @{ \GeigeII @} + >> + >> + @} + @end example + + Kommentare bilden eine Ausnahme dieser Regel. (Andere Ausnahmen + siehe @ref{Die Dateistruktur}.) Sowohl einzeilige als auch + Blockkommentare (eingegrenzt durch @code{%@{ .. %@}}) können + an beliebiger Stelle einer Eingabedatei geschrieben werden. Sie + können innerhalb oder außerhalb der @code{\score}-Umgebung vorkommen, + und innerhalb oder außerhalb des einzelnen musikalischen Ausdrucks + innerhalb der @code{\score}-Umgebung. + + + @seealso + Handbuch zum Lernen: + @rlearning{Arbeiten an Eingabe-Dateien}, + @rlearning{Musikalische Ausdrücke erklärt}, + @rlearning{Score ist ein (einziger) zusammengesetzter musikalischer Ausdruck}. + + + @node Mehrere Partituren in einem Buch + @subsection Mehrere Partituren in einem Buch + @translationof Multiple scores in a book + + @funindex \book + @cindex Sätze, mehrere + + Eine Partitur kann mehrere musikalische Stücke und verschiedene + Texte beinhalten. Beispiele hierzu sind etwa eine Etüdensammlung + oder ein Orchesterstück mit mehreren Sätzen. Jeder Satz wird + in einer eigenen @code{\score}-Umgebung notiert: + + @example + \score @{ + @var{..Noten..} + @} + @end example + + @noindent + und Texte werden mit einer @code{\markup}-Umgebung geschrieben: + + @example + \markup @{ + @var{..Text..} + @} + @end example + + @funindex \book + + Alle Sätze und Texte, die in derselben @code{.ly}-Datei vorkommen, + werden normalerweise in eine einzige Ausgabedatei gesetzt. + + @example + \score @{ + @var{..} + @} + \markup @{ + @var{..} + @} + \score @{ + @var{..} + @} + @end example + + Wenn Sie aber mehrere Ausgabedateien aus einer einzigen @code{.ly}-Datei + erstellen wollen, können Sie mehrere @code{\book}-Umgebungen notieren. + Wenn Sie keine @code{\book}-Umgebung in Ihrer Datei angeben, interpretiert + LilyPond die gesamte Datei als eine große @code{\book}-Umgebung (siehe + auch @ref{Die Dateistruktur}. Eine wichtige Ausnahme stellen Dokumente dar, + die mit lilypond-book erstellt werden, für die Sie explizit + @code{\book}-Umgebungen notieren müssen, weil sonst nur die erste + @code{\score}- bzw. @code{\markup}-Umgebung angezeigt wird. + + Der Kopfbereich für jedes Musikstück kann innerhalb der @code{\score}-Umgebung + definiert werden. Die @code{piece}-(Stück)-Bezeichnung aus dieser + @code{\header}-Umgebung wird vor jedem Satz ausgegeben. Die Überschrift für + ein ganzes Buch kann innerhalb von @code{\book} notiert werden, aber wenn + diese Umgebung fehlt, wird die @code{\header}-Umgebung genommen, die auf + erster Ebene der Datei notiert ist. + + @example + \header @{ + title = "Acht Miniaturen" + composer = "Igor Stravinsky" + @} + \score @{ + @dots{} + \header @{ piece = "Romanze" @} + @} + \markup @{ + ..Text der zweiten Strophe.. + @} + \markup @{ + ..Text der dritten Strophe.. + @} + \score @{ + @dots{} + \header @{ piece = "Menuetto" @} + @} + @end example + + @funindex \bookpart + + Stücke können innerhalb eines Buches mit @code{\bookpart} gruppiert + werden. Derartige Buchabschnitte werden durch einen Seitenumbruch + voneinander getrennt und können wie auch das ganze Buch selber mit + einem Titel innerhalb einer @code{\header}-Umgebung beginnen. + + @example + \bookpart @{ + \header @{ + title = "Buchtitel" + subtitle = "Erster Teil" + @} + \score @{ @dots{} @} + @dots{} + @} + \bookpart @{ + \header @{ + subtitle = "Zweiter Teil" + @} + \score @{ @dots{} @} + @dots{} + @} + @end example + + @node Die Dateistruktur + @subsection Die Dateistruktur + @translationof File structure + + @funindex \paper + @funindex \midi + @funindex \layout + @funindex \header + @funindex \score + @funindex \book + @funindex \bookpart + + @cindex Dateistruktur + @cindex Struktur, Datei + @cindex Eingabedatei, Struktur + @cindex Quelldatei, Struktur + + Eine @code{.ly}-Datei kann eine belibige Anzahl an Ausdrücken + auf der obersten Ebene beinhalten, wobei ein Ausdrück der obersten + Ebene einer der folgenden sein kann: + + @itemize @bullet + @item + Eine Ausgabedefinition, wie @code{\paper}, @code{\midi} und + @code{\layout}. Derartige Definitionen auf oberster Ebene verändern + die globalen Einstellungen für das ganze @qq{Buch}. Wenn mehr + als eine derarte Definition desselben Typs angegeben wird, hat + die spätere Vorrang. + + @item + Ein direkter Scheme-Ausdruck, wie etwa + @code{#(set-default-paper-size "a7" 'landscape)} oder + @code{#(ly:set-option 'point-and-click #f)}. + + @item + Eine @code{\header}-Umgebung. Damit wird die globale Titelei + eingestellt. Das ist die Umgebung, in der sich Definition für + das ganze Buch befinden, wie Komponist, Titel usw. + + @item + Eine @code{\score}-Umgebung. Die in ihr enthaltene Partitur wird + zusammen mit anderen vorkommenden @code{\score}-Umgebungen gesammelt + und in ein @code{\book} zusammengefasst. Dieses Verhalten kann + verändert werden, indem die Variable @code{toplevel-score-handler} + auf höchster Ebene gesetzt wird. Die Definition des Standards findet sich + in der Datei @file{../scm/@/lily@/.scm}. + + @item + Eine @code{\book}-Umgebung fasst mehrere Sätze (d. h. mehrere + @code{\score}-Umgebungen) logisch in ein Dokument zusammen. + Wenn mehrere @code{\score}-Partituren vorkommen, wird für jede + @code{\book}-Umgebung eine eigene Ausgabedatei erstellt, in der + alle in der Umgebung enthaltenen Partituren zusammengefasst sind. + Der einzige Grund, explizit eine @code{\book}-Umgebung zu setzen, + ist, wenn mehrere Ausgabedateien aus einer einzigen Quelldatei + erstellt werden sollen. Eine Ausnahme sind lilypond-book-Dokumente, + in denen eine @code{\book}-Umgebung explizit hinzugefügt werden + muss, wenn mehr als eine @code{\score}- oder @code{\markup}-Umgebung + im gleichen Beispiel angezeigt werden soll. Dieses Verhalten + kann verändert werden, indem die Variable @code{toplevel-book-handler} + auf höchster Ebene gesetzt wird. Die Definition des Standards + findet sich in der Datei @file{../scm/@/lily@/.scm}. + + @item + Eine @code{\bookpart}-Umgebung. Ein Buch (@code{\book}) kann in + mehrere Teile untergliedert sein, indem @code{\bookpart}-Umgebungen + eingesetzt werden. Jeder Buchabschnitt beginnt auf einer neuen + Seite und kann eigene Papierdefinitionen in einer @code{\paper}-Umgebung + haben. + + @item + Ein zusammengesetzter musikalischer Ausdruck wie etwa + @example + @{ c'4 d' e'2 @} + @end example + + Dieses Beispiel wird von LilyPond automatisch in einer + @code{\score}-Umgebung in einem Buch interpretiert und + mit anderen @code{\score}-Umgebungen und musikalischen + Ausdrücken auf der höchsten Ebene zusammen ausgegeben. + Anders gesagt: eine Datei, die nur das obige Beispiel + beinhaltet, wird übersetzt zu + + @example + \book @{ + \score @{ + \new Staff @{ + \new Voice @{ + @{ c'4 d' e'2 @} + @} + @} + @} + \layout @{ @} + \header @{ @} + @} + @end example + + Dieses Verhalten kann verändert werden, indem die Variable + @code{toplevel-music-handler} auf der oberseten Ebene gesetzt + wird. Die Definition des Standards findet sich in der Datei + @file{../scm/@/lily@/.scm}. + + @item + Eine Textbeschriftung, eine Strophe etwa: + @example + \markup @{ + 2. Die erste Zeile der zweiten Strophe. + @} + @end example + + Textbeschriftungen werden über, zwischen oder unter musikalischen + Ausdrücken gesetzt, so wie sie notiert werde. + + @cindex Variablen + + @item + Eine Variable, wie + @example + foo = @{ c4 d e d @} + @end example + + Sie kann dann später in der Datei eingesetzt werden, indem @code{\foo} + geschrieben wird. Die Beizeichnung der Variable darf nur aus + alphabetischen Zeichen bestehen, keine Zahlen, Unter- oder Bindestriche. + + @end itemize + + Das folgende Beispiel zeigt drei Dinge, die auf der obersten Ebene + notiert werden können: + + @example + \layout @{ + % Zeilen rechtsbündig setzen + ragged-right = ##t + @} + + \header @{ + title = "Do-re-mi" + @} + + @{ c'4 d' e2 @} + @end example + + An einer beliebigen Stelle der Datei kann jede der folgenden lexikalen + Anweisungen notiert werden: + + @itemize + @item @code{\version} + @item @code{\include} + @item @code{\sourcefilename} + @item @code{\sourcefileline} + @item + Ein einzeiliger Kommentar, beginnend mit @code{%}. + + @item + Ein mehrzeiliger Kommentar, umgeben von @code{%@{ .. %@}}. + + @end itemize + ++@cindex Leerzeichen ++ ++Leerzeichen zwischen Einheiten in der Eingabe werden generell ignoriert ++und können nach Belieben weggelassen werden oder hinzugefügt werden, ++um die Lesbarkeit des Codes zu verbessern. Mindestens ein Leerzeichen ++sollte jedoch unter folgenden Umständen immer eingesetzt werden, um ++Fehler zu vermeiden: ++ ++@itemize ++@item ++Vor und hinter jeder schließenden oder öffnenden Klammer, ++@item ++nach jedem Befehl oder jeder Variable, also jeder Einheit, die mit ++@code{\} beginnt, ++@item ++nach jeder Einheit, die als Scheme-Ausdruck interpretiert werden, ++also alle Einheiten, die mit @code{#} beginnen. ++@item ++Alle Einheiten von Scheme-Ausdrücken müssen mit Leerzeichen getrennt ++werden, ++@item ++in Gesangstextabschnitten (@code{lyricmode}) müssen Leerzeichen ++zwischen alle Ausdrücke in @code{\override}- und @code{\set}-Befehlen ++gesetzt werden. Insbesondere müssen um Punkte und Gleichzeitszeichen ++in Befehlen wie @code{\override Score . LyricTex #'font-size = #5)} ++und vor dem gesamten Befehl geschrieben werden. ++ ++@end itemize ++ + @seealso + Hanbuch zum Lernen: + @rlearning{Wie eine LilyPond-Eingabe-Datei funktioniert}. + + + @node Titel + @section Titel + @translationof Titles and headers + + Fast alle gedruckten Noten beinhalten einen Titel und den Namen + des Komponisten, teilweise wird auch noch sehr viel mehr Information + zur Verfügung gestellt. + + @menu + * Titel erstellen:: + * Eigene Titel:: + * Verweis auf die Seitenzahlen:: + * Inhaltsverzeichnis:: + @end menu + + + @node Titel erstellen + @subsection Titel erstellen + @translationof Creating titles + + Überschriften können für jede @code{\score}-Umgebung erstellt werden, sowohl + für die gesamte Datei (oder eine @code{\book}-Umgebung) als auch für + einzelne Buchabschnitte (innerhalb einer @code{\bookpart}-Umgebung). + + Der Inhalt der Titelei wird aus der @code{\header}-Umgebung übernommen. Die + @code{\header}-Umgebung eines Buches unterstützt folgende Felder: + + @table @code + @funindex dedication + @item dedication + Die Widmung der Noten, wird auf oben auf der ersten Seite gesetzt. + + @funindex title + @item title + Die Überschrift der Noten, wird unter der Widmung zentriert gesetzt. + + @funindex subtitle + @item subtitle + Untertitel, zentriert unter der Überschrift. + + @funindex subsubtitle + @item subsubtitle + Unteruntertitel, zentriert unter dem Untertitel. + + @funindex poet + @item poet + Name des Dichters, linksbündig unter dem Unteruntertitel. + + @funindex instrument + @item instrument + Bezeichnung des Instruments, zentriert unter dem Unteruntertitel. + Auch oben auf der Seite zentriert (andere als erste Seite). + + @funindex composer + @item composer + Name des Komponisten, rechtsbüngig unter dem Unteruntertitel. + + @funindex meter + @item meter + Metrum, linksbündig unter dem Dichter. + + @funindex arranger + @item arranger + Name des Bearbeiters/Arrangeurs, rechtsbündig unter dem Komponisten. + + @funindex piece + @item piece + Bezeichnung des Stückes, linksbündig unter dem Metrum. + + @funindex opus + @item opus + Bezeichnung des Opus, rechtsbündig unter dem Bearbeiter. + + @cindex Seitenumbruch, erzwingen + @funindex breakbefore + + @item breakbefore + Hiermit beginnt der Titel auf einer neuen Steite. (Kann die Werte + ##t (wahr) oder ##f (falsch) haben.) + + @funindex copyright + @item copyright + Anzeige eines Copyright, zentriert unten auf der ersten Seite. Um das + Copyright-Symbol zu notieren, siehe @ref{Zeichenkodierung}. + + @funindex tagline + @item tagline + Zentriert unten auf der letzten Seite. Enthält standardmäßig: @qq{Music + engraving by LilyPond (@var{version})---www.lilypond.org} + + @end table + + Hier eine Demonstration der möglichen Felder. Beliebige + Formatierungsbefehle für Textbeschriftung können in der Titelei + eingesetzt werden. Siehe hierzu auch @ref{Text formatieren}. + + @c KEEP LY + @lilypond[quote,verbatim,line-width=11.0\cm] + \paper { + line-width = 9.0\cm + paper-height = 10.0\cm + } + + \book { + \header { + dedication = "mir gewidmet" + title = \markup \center-column { "Titel erste Zeile" "Titel zweite Zeile, länger" } + subtitle = "Untertitel" + subsubtitle = #(string-append "Unteruntertitel LilyPond-Version " + (lilypond-version)) + poet = "Dichter" + composer = \markup \center-column { "Komponist" \small "(1847-1973)" } + texttranslator = "Übersetzer" + meter = \markup { \teeny "m" \tiny "e" \normalsize "t" \large "r" \huge + "um" } + arranger = \markup { \fontsize #8.5 "Be" \fontsize #2.5 "ar" \fontsize + #-2.5 "be" \fontsize #-5.3 "i" \fontsize #7.5 "ter" } + instrument = \markup \bold \italic "Instrument" + piece = "Stück" + } + + \score { + { c'1 } + \header { + piece = "Stück zwei" + opus = "Opus1" + } + } + \markup { + und jetzt... + } + \score { + { c'1 } + \header { + piece = "Stück2" + opus = "Opus2" + } + } + } + @end lilypond + + Wie schon oben gezeigt, können mehrfache @code{\header}-Umgebungen + eingesetzt werden. Wenn das gleiche Feld in mehreren + Umgebungen, wird die letzte vorkommende + Version benutzt. Hier ein kurzes Beispiel: + + @example + \header @{ + composer = "Komponist" + @} + \header @{ + piece = "Stück" + @} + \score @{ + \new Staff @{ c'4 @} + \header @{ + piece = "Neues Stück" % überschreibt die die vorige Definition + @} + @} + @end example + + Wenn @code{\header} innerhalb der @code{\score}-Umgebung definiert wird, + wird normalerweise nur die Information von @code{piece} und @code{opus} + ausgegeben. Musikalische Ausdrücke innerhalb von @code{\score} müssen + vor @code{\header} gesetzt werden. + + @lilypond[quote,verbatim,line-width=11.0\cm] + \score { + { c'4 } + \header { + title = "title" % not printed + piece = "piece" + opus = "opus" + } + } + @end lilypond + + @funindex print-all-headers + + @noindent + Dieses Verhalten kann verändert werden (sodass alle Angaben aus der + überschrift gesetzt werden, wenn sich @code{\header} innerhalb von + @code{\score} befindet), indem man schreibt: + + @example + \paper@{ + print-all-headers = ##t + @} + @end example + + @cindex Copyright + @cindex Tagline + + Die Standardfußzeile ist leer mit Ausnahme der ersten Seite, auf der + das @code{copyright}-Feld aus der @code{\header}-Umgebung eingefügt wird, + und die letzte Seite, auf der das @code{tagline}-Feld eingefügt wird. + Der Standardinhalt von @code{tagline} ist @qq{Music engraving by + LilyPond (@var{version})---www.lilypond.org}. Gut gesetzte Noten werben sehr effektiv + für LilyPond, darum bitten wir darum, diese Zeile stehen zu lassen, + wenn es möglich ist. + + Ein Titelfeld kann vollständig entfernt werden, indem es auf + falsch gesetzt wird: + + @example + \header @{ + tagline = ##f + composer = ##f + @} + @end example + + + @node Eigene Titel + @subsection Eigene Titel + @translationof Custom titles + + Kompliziertere Anpassungen können vorgenommen werden, indem die + folgenden Variablen innerhalb der @code{\paper}-Umgebung geändert + werden. Die Init-Datei @file{../ly/titling-init.ly} enthält das + Standardverhalten. + + @table @code + + @funindex bookTitleMarkup + + @item bookTitleMarkup + Das ist die Überschrift, die für das gesamte Dokument gilt. Üblicherweise + wird hier der Komponist und die Überschrift des Werkes genannt. + + @funindex scoreTitleMarkup + + @item scoreTitleMarkup + Das ist die Überschrift, die vor jede @code{\score}-Umgebung gesetzt wird. + Überlicherweise wird hier etwa die Bezeichnung eines Satzes notiert + (im @code{piece}-Feld). + + @funindex oddHeaderMarkup + + @item oddHeaderMarkup + Das ist der Seitenkopf für ungerade Seiten. + + @funindex evenHeaderMarkup + + @item evenHeaderMarkup + Das ist der Seitenkopf für gerade Seiten. Wenn undefiniert, wird der + ungerade Seitenkopf eingesetzt. + + Standardmäßig werden die Kopfzeilen so definiert, dass die Seitennummer + sich außen befindet und das Instrument zentriert gesetzt wird. + + @funindex oddFooterMarkup + + @item oddFooterMarkup + Das ist die Fußzeile für ungerade Seiten. + + @funindex evenFooterMarkup + + @item evenFooterMarkup + Das ist die Fußzeile für gerade Seiten. Wenn undefiniert, wird die + ungerade Fußzeile eingesetzt. + + Standardmäßig wird in der Fußzeile auf der ersten Seite das Copyright + und auf der letzten Seite die Tag-Zeile gesetzt. + + @end table + + + @funindex \paper + @cindex Kopfzeile + @cindex Fußzeile + @cindex Seitenlayout + @cindex Layout der Seite + @cindex Titel + @cindex Überschriften + + Die folgende Definition setzt die Überschrift linksbündig und + den Komponisten rechtsbündig auf einer einzelnen Zeile: + + @verbatim + \paper { + bookTitleMarkup = \markup { + \fill-line { + \fromproperty #'header:title + \fromproperty #'header:composer + } + } + } + @end verbatim + + + @node Verweis auf die Seitenzahlen + @subsection Verweis auf die Seitenzahlen + @translationof Reference to page numbers + + Eine bestimmte Stelle der Partitur kann mit einem @code{\label}-Befehl + markiert werden, sowohl auf oberster Ebene als auch innerhalb eines + musikalischen Ausdrucks. Auf diese Marke kann dann verwiesen werden, + um die Seitenzahl zu erhalten, auf der die Marke vorkommt. Der + Verweis wird mit dem Befehl @code{\page-ref} gefordert (innerhalb + von @code{\markup}). + + @c KEEP LY + @lilypond[verbatim,line-width=11.0\cm] + \header { tagline = ##f } + \book { + \label #'ErstePartitur + \score { + { + c'1 + \pageBreak \mark A \label #'ZeichenA + c' + } + } + + \markup { Die erste Partitur fäng auf Seite \page-ref #'ErstePartitur "0" "?" an.} + \markup { Zeichen A befindet sich auf Seite \page-ref #'ZeichenA "0" "?". } + } + @end lilypond + + Der @code{\page-ref}-Textbeschriftungsbefehl braucht drei Argumente: + + @enumerate + + @item die Marke, ein Scheme-Symbol, etwa @code{#'ErstePartitur}, + @item eine Beschriftung, die als Platzhalter benutzt wird, um die Breite des Verweisen zu schätzen, + @item eine Beschriftung, die anstelle der Seitenzahl gesetzt wird, wenn die Marke unbekann ist. + @end enumerate + + Der Grund, warum ein Platzhalter benötigt wird, ist dass zu dem Zeitpunkt, + an dem die Textbeschriftungen ausgewertet werden, noch keine Seitenumbrüche + vorgenommen wurden und die Seitenzahlen deshalb noch nicht bekannt sind. + Um hier ein Problem zu vermeiden, wird die eigentliche Auswertung der + Textbeschriftung erst später ausgeführt, die Größe des Textes muss aber + schon vorher bekannt sein. Die Größe wird mithilfe des Platzhalters + bestimmt. Wenn eine Partitur zwischen 10 und 99 Seiten hat, kann man + "00" schreiben, also eine zweistellige Zahl. + + @code{\label} + @code{\page-ref} + + @predefined + @funindex \label, + @funindex \page-ref. + @endpredefined + + + @node Inhaltsverzeichnis + @subsection Inhaltsverzeichnis + @translationof Table of contents + + Ein Inhaltsverzeichnis kann eingefügt werden mit dem Befehl + @code{\markuplines \table-of-contents}. Die Elemente, die im + Inhaltsverzeichnis aufgelistet werden sollen, werden mit dem + @code{\tocItem}-Befehl markiert, welches sowohl auf höchster + Ebene als auch in einem musikalischen Ausdruck verwendet werden + kann. + + @verbatim + \markuplines \table-of-contents + \pageBreak + + \tocItem \markup "Erste Partitur" + \score { + { + c' % ... + \tocItem \markup "Ein bestimmter Punkt innerhalb der ersten Partitur" + d' % ... + } + } + + \tocItem \markup "zweite Partitur" + \score { + { + e' % ... + } + } + @end verbatim + + Die Beschriftungen, die benutzt werden um das Inhaltsverzeichnis + zu formatieren, sind in der @code{\paper}-Umgebung definiert. + Die Standardformatierungselemente sind @code{tocTitleMarkup} + um die Überschrift zu formatieren und @code{tocItemMarkup} um + die einzelnen Inhaltselemente zu formatieren, bestehend aus + dem Titelelement und einer Seitenzahl. Die Variablen können + durch den Benutzer geändert werden: + + @verbatim + \paper { + %% Übersetzung der Inhaltsverzeichnisüberschrift nach französisch: + tocTitleMarkup = \markup \huge \column { + \fill-line { \null "Table des matières" \null } + \hspace #1 + } + %% hier größere Schriftarten + tocItemMarkup = \markup \large \fill-line { + \fromproperty #'toc:text \fromproperty #'toc:page + } + } + @end verbatim + + Die Inhaltsverzeichniselemente Text und Seitenzahl werden + in der Definition von @code{tocItemMarkup} aufgerufen mit + @code{#'toc:text} und @code{#'toc:page}. + + Neue Befehle und Beschriftungen können auch definiert werden, + um eigene Inhaltsverzeichnisse zu gestalten: + + @itemize + + @item zuerst muss eine neue Beschriftungsvariable in der + @code{\paper}-Umgebung definiert werden + + @item dann muss die musikalische Funktion definiert werden, die + ein Element zum Inhaltsverzeichnis hinzufügt, indem die neue + Variable benutzt wird. + + @end itemize + + Das folgende Beispiel definiert einen neuen Stil um Akt-Bezeichnungen + einer Oper in das Inhaltsverzeichnis aufzunehmen: + + @verbatim + \paper { + tocActMarkup = \markup \large \column { + \hspace #1 + \fill-line { \null \italic \fromproperty #'toc:text \null } + \hspace #1 + } + } + + tocAct = + #(define-music-function (parser location text) (markup?) + (add-toc-item! 'tocActMarkup text)) + @end verbatim + + @lilypond[line-width=11.0\cm] + \header { tagline = ##f } + \paper { + tocActMarkup = \markup \large \column { + \hspace #1 + \fill-line { \null \italic \fromproperty #'toc:text \null } + \hspace #1 + } + } + + tocAct = + #(define-music-function (parser location text) (markup?) + (add-toc-item! 'tocActMarkup text)) + + \book { + \markuplines \table-of-contents + \tocAct \markup { Atto Primo } + \tocItem \markup { Coro. Viva il nostro Alcide } + \tocItem \markup { Cesare. Presti omai l'Egizzia terra } + \tocAct \markup { Atto Secondo } + \tocItem \markup { Sinfonia } + \tocItem \markup { Cleopatra. V'adoro, pupille, saette d'Amore } + \markup \null + } + @end lilypond + + + @seealso + Installierte Dateien: @file{../ly/@/toc@/-init@/.ly}. + + @funindex \table-of-contents + @funindex \tocItem + + @predefined + @code{\table-of-contents}, + @code{\tocItem}. + @endpredefined + + + @node Arbeiten an Eingabe-Dateien + @section Arbeiten an Eingabe-Dateien + @translationof Working with input files + + @menu + * LilyPond-Dateien einfügen:: + * Verschiedene Editionen aus einer Quelldatei:: + * Zeichenkodierung:: + * LilyPond-Notation anzeigen:: + @end menu + + + @node LilyPond-Dateien einfügen + @subsection LilyPond-Dateien einfügen + @translationof Including LilyPond files + + @funindex \include + @cindex einfügen von Dateien + @cindex Dateien einfügen + + Ein größeres Projekt kann in einzelne Dateien aufteteilt werden. + Um eine andere Datei einzubinden, kann der Befehl + + @example + \include "andereDatei.ly" + @end example + + @noindent + benutzt werden. + + Die Zeile @code{\include "andereDatei.ly"} benimmt sich genauso, + also ob der Inhalt der Datei @code{andereDatei.ly} komplett in die + Hauptdatei eingefügt werden würde. So kann man für ein größeres + Projekt die einzelnen Stimmen der Instrumente getrennt notieren + und sie dann in einer Partitur-Datei benutzen. Meistens werden + in den eingefügten Dateien einige Variablen definiert, die dann + auch in der Hauptdatei eingesetzt werden können. Mit Marken (Tags) + gekennzeichnete Abschnitte können eingesetzt werden, um die + entsprechenden Noten etc. an verschiedenen Stellen in der Datei + zur Verfügung zu stellen. Siehe auch @ref{Verschiedene Editionen aus einer Quelldatei}. + + Auf Dateien im aktuellen Verzeichnis kann einfach mit dem Dateinamen + nach dem @code{\include}-Befehl verwiesen werden. Dateien an anderen + Stellen können eingebunden werden, indem entweder ein vollständiger + Pfad oder ein relativer Pfad zu der Datei angegeben wird. Hierbei + sollten die für UNIX typischen Schrägstriche (/) und nicht die + rückwärtsgeneigten von Windows (\) verwendet werden, um die Verzeichnisse + zu trennen. Wenn etwa die Datei @file{kram.ly} ein Verzeichnis + höher liegt als das aktuelle Verzeichnis, sollte der Befehl so + aussehen: + + @example + \include "../kram.ly" + @end example + + @noindent + Wenn die Orchesterstimmen andererseits in einem Unterordner mit + der Bezeichnung @code{stimmen} liegen, sieht er folgendermaßen + aus: + + @example + \include "stimmen/VI.ly" + \include "stimmen/VII.ly" + ... etc + @end example + + Dateien, die eingebunden werden sollen, können selber auch wiederum + ein @code{\include} enthalten. Diese Einbindung zweiter Ebene + werden erst interpretiert, wenn sie sich in der Hauptdatei befinden, + sodass die Pfadangaben hier nicht relativ zur eingebundenen Datei, + sondern relativ zur Hauptdatei gesetzt werden müssen. Dieses Verhalten + kann jedoch auch verändert werden, indem man lilypond die Option + @code{-drelative-includes} auf der Kommandozeile zuweist (oder indem + man den Befehl @code{#(ly:set-option 'relative-includes #t)} an den + Beginn der Quelldatei schreibt). Mit @code{relative-includes} wird + der Pfad jedes @code{\include}-Befehls als relativ zu der Datei angenommen, + in der sich der Befehl befindet. Dieses Verhalten wird empfohlen und wird + in zukünftigen Versionen von LilyPond den Standard darstellen. + + Dateien können auch aus einem Verzeichnis eingebunden werden, + dass im Suchpfad von LilyPond liegt. Hierzu muss auf der + Kommandozeile das entsprechende Verzeichnis angegeben werden + und die Dateien, die eingebunden werden, müssen nur mit ihrem Namen + notiert sein. Wenn etwa die Datei @file{Haupt.ly} kompiliert + werden soll, die Dateien aus dem Unterverzeichnis @file{stimmen} + einbindet, müssen sie sich im Verzeichnis von @file{Haupt.ly} + befinden und dann LilyPond folgendermaßen aufrufen: + + @example + lilypond --include=stimmen Haupt.ly + @end example + + @noindent + In @file{Haupt.ly} steht: + + @example + \include "VI.ly" + \include "VII.ly" + ... usw. + @end example + + Dateien, die in vielen Partituren verwendet werden sollen, können + im LilyPond-Verzeichnis @file{../ly} gespeichert werden. (Die + Stelle, an der dieses Verzeichnis sich befindet, hängt vom Betriebssystem + ab, siehe hierzu @rlearning{Mehr Information}). Dateien + in diesem Verzeichnis können einfach mit ihrem Namen eingefügt werden. + So werden auch die Sprachdateien wie etwa @file{deutsch.ly} eingefügt. + + LilyPond lädt eine Anzahl an Dateien, wenn das Programm aufgerufen wird. + Diese Dateien sind für den Benutzer nicht ersichtlich, aber die Dateien + können identifiziert werden, indem LilyPond auf der Komandozeile mit + Option aufgerufen wird: @code{lilypond --verbose}. Hiermit wird + neben anderer Information auch eine Liste and Pfaden und Dateien + aufgeführt, die LilyPond benutzt. Die wichtigeren Dateien werden + im Abschnitt @rlearning{Mehr Information} besprochen. + Diese Dateien können verändert werden, aber Änderungen gehen verloren, + wenn eine neue LilyPond-Version installiert wird. + + Eine einfache Beispiele, die die Benutzung von @code{\include} demonstrieren, + sind dargestellt in + @rlearning{Partituren und Stimmen}. + + @seealso + Handbuch zum Lernen: + @rlearning{Mehr Information}, + @rlearning{Partituren und Stimmen}. + + @knownissues + + Wenn eine Datei eingebunden wird, deren Name einer Datei aus + dem Installationsverzeichnis von LilyPond entspricht, wird die + installierte Datei anstelle der eigenen verwendet. + + + @node Verschiedene Editionen aus einer Quelldatei + @subsection Verschiedene Editionen aus einer Quelldatei + @translationof Different editions from one source + + Es gibt verschiedene Funktionen, die es möglich machen, unterschiedliche + Versionen einer Partitur aus der gleichen Quelldatei zu produzieren. + Variablen werden am besten eingesetzt, wenn es darum geht, längere + Notenpassagen und/oder Anmerkungen/Textmarken miteinander auf + verschiedene Weise zu kombinieren. Tag-Marken dagegen werden am + besten eingesetzt, wenn eine von mehreren kurzen alternativen + Notenabschnitten ausgewählt werden soll. Egal welche Methode am + Ende eingesetzt wird: Es erleichtert die Arbeit in jedem Fall, wenn + die eigentlichen Noten und die Struktur der Paritur voneinander + getrennt notiert werden -- so kann die Struktur geändert werden, + ohne dass man Änderungen an den Noten vornehmen muss. + + @menu + * Variablen benutzen:: + * Marken benutzen:: + @end menu + + @node Variablen benutzen + @unnumberedsubsubsec Variablen benutzen + @translationof Using variables + + @cindex Variablen, Benutzung + + Wenn Notenabschnitt in Variablen definiert werden, können sie + an unterschiedlichen Stellen in der Partitur eingesetzt werden, + siehe auch @rlearning{Stücke durch Bezeichner organisieren}. Zum + Beispiel enthält eine Vokalpartitur für ein @notation{a cappella} + Stück oft einen Klavierauszug, der das Einüben einfacher macht. + Der Klavierauszug enthält die gleichen Noten, sodass man sie nur + einmal notieren muss. Noten aus zwei Variablen können auf einem + System kombiniert werden, siehe @ref{Automatische Kombination von Stimmen}. + Hier ein Beispiel: + + @lilypond[verbatim,quote] + sopranoMusic = \relative c'' { a4 b c b8( a)} + altoMusic = \relative g' { e4 e e f } + tenorMusic = \relative c' { c4 b e d8( c) } + bassMusic = \relative c' { a4 gis a d, } + allLyrics = \lyricmode {King of glo -- ry } + << + \new Staff = "Soprano" \sopranoMusic + \new Lyrics \allLyrics + \new Staff = "Alto" \altoMusic + \new Lyrics \allLyrics + \new Staff = "Tenor" { + \clef "treble_8" + \tenorMusic + } + \new Lyrics \allLyrics + \new Staff = "Bass" { + \clef "bass" + \bassMusic + } + \new Lyrics \allLyrics + \new PianoStaff << + \new Staff = "RH" { + \set Staff.printPartCombineTexts = ##f + \partcombine + \sopranoMusic + \altoMusic + } + \new Staff = "LH" { + \set Staff.printPartCombineTexts = ##f + \clef "bass" + \partcombine + \tenorMusic + \bassMusic + } + >> + >> + @end lilypond + + Unterschiedliche Partituren, die entweder nur den Chor oder das + Klavier zeigen, können produziert werden, indem die Struktur + verändert wird; die Noten müssen dazu nicht verändert werden. + + Für längere Partituren können Variablen in eigene Dateien notiert + werden, die dann eingebunden werden, siehe @ref{LilyPond-Dateien einfügen}. + + + @node Marken benutzen + @unnumberedsubsubsec Marken benutzen + @translationof Using tags + + @cindex Tag + @cindex Marke + @cindex markierte Noten entfernen + @cindex markierte Noten behalten + + @funindex \tag + @funindex \keepWithTag + @funindex \removeWithTag + @funindex tag + @funindex keepWithTag + @funindex removeWithTag + + Der @code{\tag #'@var{TeilA}}-Befehl markiert einen musikalischen + Ausdruck mit der Bezeichnung @var{TeilA}. Ausdrücke, die auf diese + Weise markiert werden, können mit ihrer Bezeichnung später ausgewählt + bzw. ausgefiltert werden. Das geschieht mit den Befehlen + @code{\keepWithTag #'@var{Bezeichnung}} bzw. @code{\removeWithTag #'@var{Bezeichnung}}. + Die Wirkung dieser Filter auf die markierten Notenabschnitte ist + wie folgt: + + @multitable @columnfractions .5 .5 + + @headitem Filter + @tab Resultat + + @item + Markierte Noten mit vorgesetztem @code{\keepWithTag #'@var{Bezeichnung}} + @tab Unmarkierte Noten und Noten mit der Marke @var{Bezeichnung} werden + gesetzt, Noten mit einer anderen Marke werden nicht angezeigt. + + @item + Markierte Noten mit vorgesetztem @code{\removeWithTag #'@var{Bezeichnung}} + @tab Unmarkierte Noten und Noten mit einer anderen Marke als + @var{Bezeichnung} wird angezeigt, Noten markiert mit @var{Bezeichnung} + werden nicht angezeigt. + + @item + Markierte Noten, weder mit vorgesetztem @code{\keepWithTag} noch + @code{\removeWithTag} + @tab Alle markierten und unmarkierten Noten werden angezeigt. + + @end multitable + + Die Argumente der Befehle @code{\tag}, @code{\keepWithTag} und + @code{\removeWithTag} sollten ein Symbol sein (wie etwa + @code{#'score} oder @code{#'part}), gefolgt von einem musikalischen + Ausdruck. + + Im folgenden Beispiel erscheinen zwei Versionen der Noten, eine + zeigt Triller in normaler Notation, die andere zeigt sie ausgeschrieben: + + @lilypond[verbatim,quote] + music = \relative g' { + g8. c32 d + \tag #'trills {d8.\trill } + \tag #'expand {\repeat unfold 3 {e32 d} } + c32 d + } + + \score { + \keepWithTag #'trills \music + } + \score { + \keepWithTag #'expand \music + } + @end lilypond + + @noindent + Entsprechend können auch Abschnitte ausgeschlossen werden; das + erfordert manchmal weniger Schreibarbeit: + + @lilypond[verbatim,quote] + music = \relative g' { + g8. c32 d + \tag #'trills {d8.\trill } + \tag #'expand {\repeat unfold 3 {e32 d} } + c32 d + } + + \score { + \removeWithTag #'expand + \music + } + \score { + \removeWithTag #'trills + \music + } + @end lilypond + + Marken können auch auf Artikulationen, Text usw angewendet werden, + indem man ihnen + + @example + -\tag #'@var{your-tag} + @end example + + @noindent + voranstellt (jedoch nach der Note, an die sie gebunden sind). Mit + diesem Code etwa könnte man entweder Fingersatz oder aber einen + Text ausgeben: + + @example + c1-\tag #'finger ^4 + c1-\tag #'warn ^"Achtung!" + @end example + + Mehrfache Marken können mithilfe von mehreren @code{\tag}-Befehlen + notiert werden: + + @lilypond[quote,verbatim] + music = \relative c'' { + \tag #'a \tag #'both { a a a a } + \tag #'b \tag #'both { b b b b } + } + << + \keepWithTag #'a \music + \keepWithTag #'b \music + \keepWithTag #'both \music + >> + @end lilypond + + Mehrfache @code{\removeWithTag}-Filter können auf einen + musikalischen Ausdruck angewendet werden, um mehrere unterschiedliche + markierte Abschnitte aus dem Druckbild zu entfernen. + + @lilypond[verbatim,quote] + music = \relative c'' { + \tag #'A { a a a a } + \tag #'B { b b b b } + \tag #'C { c c c c } + \tag #'D { d d d d } + } + { + \removeWithTag #'B + \removeWithTag #'C + \music + } + @end lilypond + + Zwei oder mehr @code{\keepWithTag}-Filter in einem musikalischen + Ausdruck bewirken, dass @emph{alle} markierten Abschnitte entfernt + werden, weil der erste Befehl alle markierten Abschnitt außer dem + im Befehl genannten wegfiltert und der zweite Befehl dann auch diesen + eben genannten zusätzlich entfernt. + + + @seealso + Handbuch zum Lernen: + @rlearning{Stücke durch Bezeichner organisieren}. + + Notationsreferenz: + @ref{Automatische Kombination von Stimmen}, + @ref{LilyPond-Dateien einfügen}. + + + @ignore + @c This warning is more general than this placement implies. + @c Rests are not merged whether or not they come from tagged sections. + @c Should be deleted? -td + + @knownissues + + Multiple rests are not merged if you create a score with more + than one tagged section at the same place. + + @end ignore + + + @node Zeichenkodierung + @subsection Zeichenkodierung + @translationof Text encoding + ++@cindex Unicode ++@cindex UTF-8 ++@cindex Nicht-ASCII-Zeichen ++ + LilyPond benutzt alle Zeichen, die durch das Unicode-Konsortium + und ISO/IEC 10646 definiert sind. Hiermit wird den Zeichen + fast aller Schriftsysteme der Welt ein eindeutiger Name und ein + Code-Punkt zugewiesen, mit dem sie identifizierbar sind. Unicode + kann mit mehreren Zeichenkodierungen verwirklicht werden. LilyPond + benutzt die UTF-8-Kodierung (UTF = Unicode Transformation Format), + in der die normalen Zeichen des lateinischen Alphabets mit einem + Byte dargestellt werden, während alle anderen Zeichen zwischen + zwei und vier Byte Länge haben. + + Das Aussehen des Zeichens wird bestimmt durch die gerade benutzte + Schriftart (engl. font). In einer Schriftartdatei werden die + Nummern der Unicode-Zeichen einem bestimmten Glyphen zugeordnet. + LilyPond verwendet die Pango-Bibliothek um mehrsprachige Texte + und komplexe Skripte korrekt zu setzen. + + LilyPond verändert die Kodierung der Eingabedatei nicht. Das heißt, + dass jeder Text -- Überschriften, Gesangstext, Spielanweisungen etc. -- + der nicht nur aus ASCII-Zeichen besteht, in UTF-8 kodiert sein + musst. Am einfachsten geht das, indem man einen Texteditor + einsetzt, der mit Unicode-Zeichen umgehen kann. Die meisten + modernen weit verbreiteten Editoren besitzen heute UTF-8-Unterstützung, + wie etwa vim, Emacs, jEdit oder GEdit. Alle MS Windows-Systeme + nach NT benutzen Unicode intern, sodass sogar Notepad Dateien + in UTF-8 lesen und speichern kann. Ein Editor mit mehr + Funktionen unter Windows ist BabelPad oder Notepad++. + + Wenn eine LilyPond-Eingabedatei nicht-ASCII-Zeichen enthält + und nicht in UTF-8 gespeichert ist, gibt es folgende Fehlermeldung: + + @example + FT_Get_Glyph_Name () error: invalid argument + @end example + + Heir ein Beispiel mit Kyrilliza, hebräischem und portugiesischem Text: + + @lilypond[quote] + %c No verbatim here as the code does not display correctly in PDF + % Cyrillic + bulgarian = \lyricmode { + Жълтата дюля беше щастлива, че пухът, който цъфна, замръзна като гьон. + } + + % Hebrew + hebrew = \lyricmode { + זה כיף סתם לשמוע איך תנצח קרפד עץ טוב בגן. + } + + % Portuguese + portuguese = \lyricmode { + à vo -- cê uma can -- ção legal + } + + \relative { + c2 d e f g f e + } + \addlyrics { \bulgarian } + \addlyrics { \hebrew } + \addlyrics { \portuguese } + @end lilypond + + Um einen einzelnen Buchstaben zu notieren, für den die Unicode-Ziffernfolge + bekannt ist, der aber nicht auf der Tastatur zu finden ist, kann + der Befehl @code{\char ##xhhhh} oder @code{\char #dddd} innerhalb einer + @code{\markup}-Umgebung benutzt werden. Hierbei bedeutet @code{hhhh} die + hexadezimale Zahl und @code{ddd} die entsprechende dezimale Zahl + für das erforderliche Zeichen. Nullen zu Beginn können ausgelassen werden, + aber normalerweise werden alle vier Zeichen der hexadezimalen Notation + notiert. (Achten Sie darauf, dass Sie @emph{nicht} UTF-8-Codepunkte + einsetzen, weil UTF-8 zusätzliche Bits enthält, die die Nummer der Oktets bezeichnet.) + + Mit @code{\char ##x03BE} und @code{\char #958} wird + beispielsweise das Unicode-Zeichen U+03BE notiert, welches die + Unicode-Bezeichnung @qq{Greek Small Letter Xi} hat. + + Alle existierenden + Unicode-Zeichen können auf diese Weise notiert werden, und wenn für alle + Zeichen dieses Format angewandt wird, muss die Datei nicht im utf-8-Format + gespeichert werden. Es muss natürlich auch noch eine Schriftart auf + dem System installiert sein, die die notierten Zeichen darstellen kann. + + Das nächste Beispiel zeigt, wie Unicode-Zeichen an vier Stellen mit dem + hexadezimalen Code notiert werden: in einem Übungszeichen, als Artikulationszeichen, + im Gesangstext und als normaler Text außerhalb der Partitur. + + @lilypond[quote,verbatim] + \score { + \relative c'' { + c1 \mark \markup { \char ##x03EE } + c1_\markup { \tiny { \char ##x03B1 " to " \char ##x03C9 } } + } + \addlyrics { O \markup { \concat{ Ph \char ##x0153 be! } } } + } + \markup { "Copyright 2008--2009" \char ##x00A9 } + @end lilypond + ++@cindex Copyright-Zeichen ++ + Um das Copyright-Zeichen zu notieren, kann folgender Code eingesetzt werden: + + @example + \header @{ + copyright = \markup @{ \char ##x00A9 "2008" @} + @} + @end example + + + @node LilyPond-Notation anzeigen + @subsection LilyPond-Notation anzeigen + @translationof Displaying LilyPond notation + + @funindex \displayLilyMusic + + Ein musikalischer Ausdruck in LilyPond-Notation kann mit der Funktion + @code{\displayMusic} angezeigt werden. Der Code + + @example + @{ + \displayLilyMusic \transpose c a, @{ c e g a bes @} + @} + @end example + + @noindent + etwa wird ausgeben: + + @example + @{ a, cis e fis g @} + @end example + + Normalerweise werden diese Zeilen zusammen mit allen anderen + Nachrichten auf der Kommandozeile ausgegeben. Um sie separat zu + speichern und das Ergebnis von @code{\displayMusic} weiterzubenutzen, + kann die Ausgabe mit folgendem Befehl in eine Datei umgeleitet werden: + + @c TODO What happens under Windows? + + @example + lilypond file.ly >display.txt + @end example + + + + @node Ausgabe kontrollieren + @section Ausgabe kontrollieren + @translationof Controlling output + + @menu + * Notationsfragmente extrahieren:: + * Korrigierte Musik überspringen:: + @end menu + + + @node Notationsfragmente extrahieren + @subsection Notationsfragmente extrahieren + @translationof Extracting fragments of music + + Es ist möglich, kleine Abschnitte einer großen Partitur direkt aus der + Quelldatei zu erzeugen. Das kann damit verglichen werden, dass man + mit der Schere bestimmte Regionen ausschneidet. + + Es wird erreicht, indem man die Takte, die ausgeschnitten werden sollen + (engl. to clip = ausschneiden), extra definiert. Mit folgender + Defintion beispielsweise + + @verbatim + \layout { + clip-regions + = #(list + (cons + (make-rhythmic-location 5 1 2) + (make-rhythmic-location 7 3 4))) + } + @end verbatim + + @noindent + wird ein Fragment ausgeschnitten, dass auf der Mitte des fünften Taktes + beginnt und im siebten Takt endet. Die Bedeutung von @code{5 1 2} ist: + nach einer Halben in Takt fünf, @code{7 3 4} heißt: nach drei Vierteln + in Takt 7. + + Weitere Bereiche, die ausgeschnitten werden sollen, können definiert + werden, indem mehrere derartige Paare definiert werden. + + Um diese Funktion auch nutzen zu können, muss LilyPond mit dem + Parameter @code{-dclip-systems} aufgerufen werden. Die Schnipsel + werden als EPS ausgegeben und dann zu PDF und PNG konvertiert, wenn + diese Formate auch als Parameter angegeben werden. + + Zu mehr Information über Ausgabeformate siehe @rprogram{lilypond aufrufen}. + + + @node Korrigierte Musik überspringen + @subsection Korrigierte Musik überspringen + @translationof Skipping corrected music + + + @funindex skipTypesetting + @funindex showFirstLength + @funindex showLastLength + + Wenn man Noten eingibt oder kopiert, sind meistens nur die Noten nahe dem + Ende (wo gerade neue Noten notiert wurden) wichtig für Kontrolle und + Korrektur. Um die Korrektur zu beschleunigen, kann eingestellt werden, + dass nur die letzten paar Takte angezeigt werden. Das erreicht man + mit dem Befehl + + @verbatim + showLastLength = R1*5 + \score { ... } + @end verbatim + + @noindent + in der Quelldatei. Damit werden nur die letzten fünf Takte (in einem + 4/4-Takt) eines jeden @code{\score}-Abschnitts übersetzt. Besonders + bei längeren Stücken ist es meistens sehr viel schneller, nur einen + kleinen Teil des Stückes zu setzen als die gesamte Länge. Wenn man + am Anfang eines Stückes arbeitet (weil etwa ein neuer Teil hinzugefügt + werden soll), kann auch die @code{showFirstLength}-Eigenschaft + nützlich sein. + + Nur bestimmte Teile einer Partitur zu überspringen, kann mit der + Eigenschaft @code{Score.skipTypesetting} sehr genau kontrolliert + werden. Für den Bereich, für den sie auf @qq{wahr} gesetzt wird, + wird kein Notensatz ausgegeben. + + Diese Eigenschaft kann auch benutzt werden, um die MIDI-Ausgabe zu + kontrollieren. Hiermit werden alle Ereignisse, auch Tempo- und + Instrumentenwechsel ausgelassen. Man muss also sehr genau darauf + achten, dass nichts unerwartetes geschieht. + + @lilypond[quote,fragment,ragged-right,verbatim] + \relative c'' { + c8 d + \set Score.skipTypesetting = ##t + e e e e e e e e + \set Score.skipTypesetting = ##f + c d b bes a g c2 } + @end lilypond + + In polyphoner Notation wirkt sich @code{Score.skipTypesetting} auf + alle Stimmen und Systeme aus, sodass noch mehr Zeit bei der + Übersetzung der Datei gespart wird. + + + @node MIDI-Ausgabe + @section MIDI-Ausgabe + @translationof MIDI output + + @cindex Klang + @cindex MIDI + + MIDI (Musical Instrument Digital Interface) ist ein Standard zur + Kontrolle und Interaktion mit digitalen Instrumenten. Eine + MIDI-Datei ist eine Anzahl von Noten auf einer Anzahl von + Bändern/Stimmen. Es ist keine eigentliche Klangdatei, denn man + benötigt spezielle Programme die die Notenereignisse in Klang + umwandeln können. + + Der Notensatz von LilyPond kann in MIDI umgewandelt werden, so dass + man sich anhören kann, was man notiert hat. Das hilft oft sehr gut + bei der Überprüfung: falsche Oktaven oder falsche Versetzungszeichen + lassen sich meist sehr gut hören. + + Die MIDI-Ausgabe benötigt einen Kanal für jedes System und einen für + globale Einstellungen. Darum sollte die Quelldatei für eine MIDI-Datei + nicht mehr als 15 Systeme (oder 14 wenn kein Schlagzeug benützt wird) + besitzen. Jedes weitere System bleibt stumm. + + + @menu + * MIDI-Dateien erstellen:: + * Der MIDI-Block:: + * Was geht in die MIDI-Ausgabe:: + * Wiederholungen im MIDI:: + * MIDI-Lautstärke kontrollieren:: + * Schlagzeug in MIDI:: + @end menu + + + @node MIDI-Dateien erstellen + @subsection MIDI-Dateien erstellen + @translationof Creating MIDI files + + Um eine MIDI-Datei aus einer LilyPond-Quelldatei zu erstellen, muss + eine @code{\midi}-Umgebung zu der @code{\score}-Umgebung hinzugefügt + werden, etwa so: + + @example + \score @{ + @var{...Noten...} + \midi @{ @} + @} + @end example + + Wenn in einer @code{\score}-Umgebung nur eine @code{\midi}-Umgebung, + aber keine @code{\layout}-Umgebung vorkommt, wird nur MIDI produziert. + Wenn auch die Notation gewünscht ist, muss zusätzlich die + @code{\layout}-Umgebung vorhanden sein: + + @example + \score @{ + @var{...music...} + \midi @{ @} + \layout @{ @} + @} + @end example + + Tonhöhen, Rhythmen, Überbindungen, Dynamik und Tempoänderungen werden + korrekt in das MIDI-Format übersetzt. Dynamikzeichen, Crescendo und + Decrescendo werden in den MIDI-Lautstärkekanal übertragen. Dynamikzeichen + werden in einen bestimmten Lautstärkenwert übersetzt, Crescendo und + Decrescendo erreichen einen Übergang zwischen Lautstärkewerten. + Die Wirkung von Dynamikzeichen kann auch aus der MIDI-Datei entfernt + werden. Siehe hierzu @ref{Der MIDI-Block}. + + Das Anfangstempo und spätere Tempoänderungen können mit dem + @code{\tempo}-Befehl innerhalb der Notation notiert werden. Er + bewirkt Tempoänderungen auch in der MIDI-Datei. Der Befehl setzt + gleichzeitig auch eine Tempobezeichnung in die Noten, welches aber + auch unterdrückt werden kann, siehe @ref{Metronomangabe}. Eine + andere möglichkeit, ein eigenes MIDI-Tempo anzugeben, wird weiter + unten gezeigt, siehe @ref{Der MIDI-Block}. + + Aufgrund einiger Einschränkungen auf Windows ist auf Windows-Systemen + die Standarddateierweiterung von MIDI-Dateien @code{.mid}. Andere + Betriebssysteme verwenden weiterhin @code{.midi}. Wenn eine + andere Endung erwünscht ist, kann man die folgende Zeile auf oberster + Ebene der Quelldatei, vor Beginn eines @code{\book}, @code{\bookpart} + oder @code{\score}-Blocks einfügen: + + @example + #(ly:set-option 'midi-extension "midi") + @end example + + Diese Codezeile setzt die Dateiendung auf @code{.midi}. + + Als Alternative kann man diese Option auch als Kommandozeilenparameter + übergeben: + + @example + lilypond … -dmidi-extension=midi lilyDatei.ly + @end example + + @unnumberedsubsubsec Instrumentenbezeichnungn + + @cindex Instrumentbezeichnungen + + @funindex Staff.midiInstrument + + Das MIDI-Instrument, mit dem ein bestimmtes System wiedergegeben + werden soll, wird durch die @code{Staff.midiInstrument}-Eigenschaft + bestimmt, die auf eine Instrumentenbezeichnung gesetzt werden muss. + Die Bezeichnungen sind aufgelistet in @ref{MIDI-Instrumente} und müssen + in der dort definierten Schreibweise notiert werden. + + @example + \new Staff @{ + \set Staff.midiInstrument = #"glockenspiel" + @var{...Noten...} + @} + @end example + + @example + \new Staff \with @{midiInstrument = #"cello"@} @{ + @var{...Noten...} + @} + @end example + + Wenn die Schreibweise nicht genau einem definierten Instrument aus + der Liste entpsricht, wird ein Piano-Klang benutzt (@code{"acoustic grand"}). + + @snippets + + @lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] + {changing-midi-output-to-one-channel-per-voice.ly} + + @knownissues + + Veränderungen der MIDI-Lautstärke sind nur effektiv, wenn sie zu Beginn + einer Note angefordert werden, sodass die Lautstärke während einer Notendauer + nicht geändert werden kann. + + Nicht alle MIDI-Spieler können Tempoänderungen richtig wiedergeben. + Spieler, die hierzu in der Lage sind, sind unter Anderen MS Windows Media + Player und @uref{http://@/timidity@/.sourceforge@/.net/,timidity}. + + + @node Der MIDI-Block + @subsection Der MIDI-Block + @translationof MIDI block + + @cindex MIDI-Umgebung + + Eine @code{\midi}-Umgebung muss innerhalb von einer @code{\score}-Umgebung + vorkommen, wenn MIDI-Ausgabe gewünscht ist. Sie entspricht der + @code{\layout}-Umgebung, aber ist etwas einfacher aufgebaut. Oft wird + die MIDI-Umgebung einfach leer gelassen, aber hier können auch + Kontexte umgeändert werden, neue Kontexte definiert werden oder + neue Werte definiert werden. Das folgende Beispiel etwa definiert + das MIDI-Tempo, ohne dass in der Partitur eine Metronombezeichnung + gesetzt wird: + + @example + \score @{ + @var{...Noten...} + \midi @{ + \context @{ + \Score + tempoWholesPerMinute = #(ly:make-moment 72 4) + @} + @} + @} + @end example + + Hier wird das Tempo auf 72 Viertelnoten pro Minute definiert. Wenn + das Tempo auf diese Weise definiert wird, kann keine punktierte + Note als Einheit angegeben werden. Wenn sie benötigt wird, muss + man sie in kleinere Einheiten auflösen. Ein Tempo von 90 punktierten + Viertelnoten pro Minute kann beispielsweise dargestellt werden + als 270 Achtelnoten pro Minute: + + @example + tempoWholesPerMinute = #(ly:make-moment 270 8) + @end example + + @cindex MIDI-Kontextdefinitionen + + Kontextdefinitionen des @code{\midi}-Kontextes entsprechen + der Syntax, wie sie in der @code{\layout}-Umgebung benutzt + wird. Klangübersetzungsmodule werden @code{performer} + genannt. Die Kontexte für die MIDI-Ausgabe sind in der + Datei @file{../ly/@/performer@/-init@/.ly} definiert, siehe + @rlearning{Mehr Information}. Um beispielsweise + die Auswirkung von Dynamikzeichen aus der MIDI-Ausgabe zu + entfernen, müssen folgende Zeilen eingefügt werden: + + @example + \midi @{ + ... + \context @{ + \Voice + \remove "Dynamic_performer" + @} + @} + @end example + + Eine MIDI-Ausgabe wird nur erstellt, wenn die @code{\midi}-Umgebung + in eine Partiturumgebung eingefügt wird, die mit dem Befehl + @code{\score} beginnt. Wenn eine Partitur explizit etwa mit + @code{\new Score} begonnen wird, und sich die MIDI-Umgebung hierin + befindet, wird keine Ausgabe produziert. Eine Lösung ist es, sowohl + die @code{\new Score}- als auch die @code{\midi}-Umgebungen in eine + @code{\score}-Umgebung einzuschließen. + + @example + \score @{ + \new Score @{ @dots{}Noten@dots{} @} + \midi @{ @} + @} + @end example + + + @node Was geht in die MIDI-Ausgabe + @subsection Was geht in die MIDI-Ausgabe + @translationof What goes into the MIDI output? + + + @unnumberedsubsubsec In MIDI unterstützt + + @cindex Tonhöhen in MIDI + @cindex MIDI, Tonhöhen + @cindex Vierteltöne in MIDI + @cindex MIDI, Vierteltöne + @cindex Mikrotöne in MIDI + @cindex MIDI, Mikrotöne + @cindex Akkordsymbole in MIDI + @cindex MIDI, Akkordsymbole + @cindex Rhythmen in MIDI + @cindex MIDI, Rhythmen + + Die folgenden Notationselemente werden in die MIDI-Ausgabe aufgenommen: + + @itemize + @item Tonhöhen + @item Mikrotöne (siehe @ref{Versetzungszeichen}. Für die Ausgabe wird ein + Spieler benötigt, der Tonhöhen verändern kann.) + @item Akkorde, die als Symbole notiert werden + @item Rhythmen, die als Dauern notiert sind, inklusive N-tolen + @item Tremolo, das ohne @q{@code{:}[@var{Zahl}]} notiert ist + @item Überbindungen + @item Dynamikzeichen + @item Crescendi, decrescendi zu mehreren Noten + @item Tempoänderungen, die mit einer Tempo-Bezeichnung eingegeben werden + @item Gesangstext + @end itemize + + + @unnumberedsubsubsec In MIDI nicht unterstützt + + Folgende Notationselemente werden nicht in die MIDI-Ausgabe einbeozogen: + + @itemize + @item Rhythmus, der als Anmerkung notiert wird, bspw. Swing + @item Tempoveränderungen, die als Anmerkung ohne Tempobezeichnung notiert werden + @item Staccato und andere Artikultationen und Ornamente + @item Legato- und Phrasierungsbögen + @item Crescendi, decrescendi zu einer einzelnen Note + @item Tremolo, notiert mit @q{@code{:}[@var{number}]} + @item Bezifferter Bass + @item Akkorde mit Mikrotönen + @end itemize + + + @node Wiederholungen im MIDI + @subsection Wiederholungen im MIDI + @translationof Repeats in MIDI + + @cindex Wiederholungen in MIDI + @cindex MIDI und Wiederholungen + + @funindex \unfoldRepeats + + Mit einigen Veränderungungen im Notentext können alle Wiederholungstypen + auch in der MIDI-Ausgabe wiedergegeben werden. Das wird erreicht, indem + die @code{\unfoldRepeats}-Funktion eingesetzt wird. Diese Funktion + verändert alle Wiederholungen in ausgeschriebene Noten. + + @lilypond[quote,verbatim] + \unfoldRepeats { + \repeat tremolo 8 {c'32 e' } + \repeat percent 2 { c''8 d'' } + \repeat volta 2 {c'4 d' e' f'} + \alternative { + { g' a' a' g' } + {f' e' d' c' } + } + } + \bar "|." + @end lilypond + + Wenn eine Partitur mit diesem Befehl erstellt wird, ist er notwendig, + zwei @code{\score}-Umgebungen einzurichten: in der einen werden die + Wiederholungen ausgeschrieben und nur eine MIDI-Ausgabe produziert, + in der anderen werden die Wiederholungen notiert und als Partitur + gesetzt. Das Beispiel gibt einen Hinweis, wie eine derartige Datei + aussehen kann: + + @example + \score @{ + @var{..music..} + \layout @{ .. @} + @} + \score @{ + \unfoldRepeats @var{..music..} + \midi @{ .. @} + @} + @end example + + + @node MIDI-Lautstärke kontrollieren + @subsection MIDI-Lautstärke kontrollieren + @translationof Controlling MIDI dynamics + + Dynamik in der MIDI-Ausgabe wird durch den Dynamic_performer + erstellt, welcher sich in einem @code{Voice}-Kontext befindet. + Es ist möglich, sowohl die generelle Lautstärke einer MIDI-Datei + als auch relative Lautstärken von Dynamikanweisungen und auch + relative Lautstärke von einzelnen Instrumenten einzustellen. + + + @unnumberedsubsubsec Dynamik-Zeichen + + + Dynamikanweisungen werden als ein bestimmter Bruch der insgesamt + zur Verfügung stehenden MIDI-Lautstärke notiert. Die Standardbrüche + reichen von 0,25 für @notation{ppppp} bis hin zu 0,95 für + @notation{fffff}. Diese Anweisung befinden sich in der Datei + @file{../scm/midi.scm}, siehe auch @rlearning{Mehr Information}. + Diese Brüche können nach Belieben geändert oder erweitert werden, indem + eine Funktion erstellt wird, die ein Dynamikzeichen als Argument + nimmt und den erforderlichen Bruch ausgibt; schließlich muss noch + @code{Score.dynamicAbsoluteVolumeFunction} auf diese Funktion + gesetzt werden. + + Beispielhaft soll gezeigt werden, wie man eine @notation{Rinforzando}-Dynamik, + @code{\rfz}, auch in die MIDI-Ausgabe übernehmen kann. Gleiches gilt + für neue, selbstdefinierte Dynamikzeichen, die in den Standarddefinitionen + nicht enthalten sind. Die Scheme-Funktion, die hier definiert wird, + setzt den Bruch von 0,9 für eine rfz-Anweisung und ruft andernfalls die + Standardanweisungen auf: + + @lilypond[verbatim,quote] + #(define (myDynamics dynamic) + (if (equal? dynamic "rfz") + 0.9 + (default-dynamic-absolute-volume dynamic))) + + \score { + \new Staff { + \set Staff.midiInstrument = #"cello" + \set Score.dynamicAbsoluteVolumeFunction = #myDynamics + \new Voice { + \relative c'' { + a\pp b c-\rfz + } + } + } + \layout {} + \midi {} + } + @end lilypond + + Alternativ, insbesondere wenn die gesamte Tabelle der MIDI-Lautstärken + umdefiniert werden soll, ist es besser, die + @notation{default-dynamic-absolute-volume}-Prozedur in der Datei + @file{../scm/midi.scm} und die hiermit verknüpfte Tabelle als Modell + zu benutzen. Das letzte Beispiel dieses Abschnittes zeigt, wie das + gemacht werden kann. + + + @unnumberedsubsubsec MIDI-Lautstärke + + Die generellen Mindest- und Höchstwerte für die Lautstärke der MIDI-Datei + wird kontrolliert, indem die Eigenschaften @code{midiMinimumVolume} + unde @code{midiMaximumVolume} auf der @code{Score}-Ebene gesetzt + werden. Diese Eigenschaften haben nur Einfluss auf Dynamikzeichen, sodass + ein Dynamikzeichen direkt an den Anfang der Partitur gestellt werden muss, + wenn diese Einstellung von Anfang an Wirkung zeigen soll. Der Bruch, + der dann den einzelnen Dynamikzeichen entspricht, wird mit der + Formel + + @example + midiMinimumVolume + (midiMaximumVolume - midiMinimumVolume) * Bruch + @end example + + @noindent + errechnet. Im folgenden Beispiel wird die generelle MIDI-Lautstärke + auf den Bereich zwischen 0.2 und 0.5 eingeschränkt. + + @lilypond[verbatim,quote] + \score { + << + \new Staff { + \key g \major + \time 2/2 + \set Staff.midiInstrument = #"flute" + \new Voice \relative c''' { + r2 g\mp g fis ~ + fis4 g8 fis e2 ~ + e4 d8 cis d2 + } + } + \new Staff { + \key g \major + \set Staff.midiInstrument = #"clarinet" + \new Voice \relative c'' { + b1\p a2. b8 a + g2. fis8 e + fis2 r + } + } + >> + \layout { } + \midi { + \context { + \Score + tempoWholesPerMinute = #(ly:make-moment 72 2) + midiMinimumVolume = #0.2 + midiMaximumVolume = #0.5 + } + } + } + @end lilypond + + + @unnumberedsubsubsec Verschiedene Instrumente angleichen (i) + + Wenn die Mindest- und Höchstwerte für die MIDI-Lautstärke + innerhalb eines @code{Staff}-Kontextes gesetzt werden, + kann damit die relative Lautstärke einzelner Instrumente kontrolliert + werden. Damit kann man die Qualität der MIDI-Datei + merklich verbessern. + + In diesem Beispiel wird die Lautstärke der Klarinette relativ + zur Lautstärke der Flöte verringert. In jeder Stimme muss + eine Dynamikanweisung für die erste Note gesetzt werden, damit + diese Einstellung korrekt funktioniert. + + @lilypond[verbatim,quote] + \score { + << + \new Staff { + \key g \major + \time 2/2 + \set Staff.midiInstrument = #"flute" + \set Staff.midiMinimumVolume = #0.7 + \set Staff.midiMaximumVolume = #0.9 + \new Voice \relative c''' { + r2 g\mp g fis ~ + fis4 g8 fis e2 ~ + e4 d8 cis d2 + } + } + \new Staff { + \key g \major + \set Staff.midiInstrument = #"clarinet" + \set Staff.midiMinimumVolume = #0.3 + \set Staff.midiMaximumVolume = #0.6 + \new Voice \relative c'' { + b1\p a2. b8 a + g2. fis8 e + fis2 r + } + } + >> + \layout { } + \midi { + \context { + \Score + tempoWholesPerMinute = #(ly:make-moment 72 2) + } + } + } + @end lilypond + + + @unnumberedsubsubsec Verschidene Instrumente angleichen (ii) + + Wenn Mindest- und Höchstwerte für die Lautstärke der MIDI-Datei + nicht vorgegeben werden, nimmt LilyPond standardmäßig einige + Anpassungen für die Lautstärken bestimmter Instrumente vor. + Diese Instrumente und ihre entsprechende Veränderung lassen + sich aus der Tabelle @notation{instrument-equalizer-alist} + in der Datei @file{../scm/midi.scm} entnehmen. + + Dieser grundlegende Equalizer kann ersetzt werden, indem die + Funktion @code{instrumentEqualizer} im @code{Score}-Kontext auf + eine neue Scheme-Funktion gesetzt wird, die MIDI-Instrumentbezeichnungen + als einziges Argument akzeptiert und ein Zahlenpaar ausgibt, das + den Höchst- und Mindestwert für die Lautstärke des entpsrechenden + Instruments darstellt. Die Ersetzung der Standardfunktion wird + auf gleiche Weise vorgenommen, wie es schon für die + @code{dynamicAbsoluteVolumeFunction} zu Beginn dieses Abschnittes + gezeigt wurde. Der Standard-Equalizer, + @notation{default-instrument-equalizer} in der Datei + @file{../scm/midi.scm} zeigt, wie solche eine Funktion erstellt werden + kann. + + Das folgende Beispiel definiert für die Flöte und Klarinette relative + Lautstärkewerte, die denen des vorigen Beispiels entsprechen. + + @lilypond[verbatim,quote] + #(define my-instrument-equalizer-alist '()) + + #(set! my-instrument-equalizer-alist + (append + '( + ("flute" . (0.7 . 0.9)) + ("clarinet" . (0.3 . 0.6))) + my-instrument-equalizer-alist)) + + #(define (my-instrument-equalizer s) + (let ((entry (assoc s my-instrument-equalizer-alist))) + (if entry + (cdr entry)))) + + \score { + << + \new Staff { + \key g \major + \time 2/2 + \set Score.instrumentEqualizer = #my-instrument-equalizer + \set Staff.midiInstrument = #"flute" + \new Voice \relative c''' { + r2 g\mp g fis ~ + fis4 g8 fis e2 ~ + e4 d8 cis d2 + } + } + \new Staff { + \key g \major + \set Staff.midiInstrument = #"clarinet" + \new Voice \relative c'' { + b1\p a2. b8 a + g2. fis8 e + fis2 r + } + } + >> + \layout { } + \midi { + \context { + \Score + tempoWholesPerMinute = #(ly:make-moment 72 2) + } + } + } + @end lilypond + + + + @node Schlagzeug in MIDI + @subsection Schlagzeug in MIDI + @translationof Percussion in MIDI + + Schlagzeuginstrumente werden üblicherweise in einem @code{DrumStaff}-Kontext + notiert. Aus diese Weise werden sie korrekt in den MIDI-Kanal@tie{}10 + ausgegeben. Eine Schlagzeuge mit diskreten Tonhöhen, wie Xylophon, + Marima, Vibraphone, Pauken usw. werden wie @qq{normale} Instrumente + in einem @code{Staff}-Kontext notiert. Nur so lässt sich auch hier + eine richtige MIDI-Ausgabe erreichen. + + Einige Instrumente, die keine diskreten Tonhöhen haben, können nicht + über den MIDI-Kanal@tie{}10 erreicht werden und müssen deshalb in + einem normalen @code{Staff}-Kontext notiert werden. Es handelt sich + um @code{melodic tom, taiko drum, synth drum} usw. + + Viele Schlagzeuginstrumnete sind nicht in den MIDI-Standard aufgenommen, + z. B. Kastagnetten. Die einfachste Methode, derartige Instrumente + zu ersetzen, ist, einen Klang auszuwählen, der ihnen halbwegs ähnlich + kommt. + + + @knownissues + + Weil der MIDI-Standard keine Peitschenschläge kennt, wird ein + Schlagstock (sidestick) für diesen Zweck eingesetzt. diff --cc Documentation/de/notation/pitches.itely index 0000000000,ce54cd0b73..dbb52c1e33 mode 000000,100644..100644 --- a/Documentation/de/notation/pitches.itely +++ b/Documentation/de/notation/pitches.itely @@@ -1,0 -1,2546 +1,2546 @@@ + @c -*- coding: utf-8; mode: texinfo; documentlanguage: de -*- + @ignore + Translation of GIT committish: da96eee19a7529842725d0c374ea356987100f91 + + When revising a translation, copy the HEAD committish of the + version that you are working on. See TRANSLATION for details. + @end ignore + + @c \version "2.12.0" + + @node Tonhöhen + @section Tonhöhen + @translationof Pitches + + @lilypondfile[quote]{pitches-headword.ly} + + Dieser Abschnitt zeigt, wie man die Tonhöhe notieren kann. + Es gibt drei Stufen in diesem Prozess: Eingabe, + Veränderung und Ausgabe. + + @menu + * Tonhöhen setzen:: + * Viele Tonhöhen gleichzeitig verändern:: + * Tonhöhen anzeigen lassen:: + * Notenköpfe:: + @end menu + + + @node Tonhöhen setzen + @subsection Tonhöhen setzen + @translationof Writing pitches + + Dieser Abschnitt zeigt, wie man Tonhöhen notiert. Es gibt + zwei verschiedene Möglichkeiten, Noten in bestimmten + Oktaven zu notieren: den absoluten und den relativen + Modus. In den meisten Fällen eignet sich der relative + Modus besser. + + @menu + * Absolute Oktavenbezeichnung:: + * Relative Oktavenbezeichnung:: + * Versetzungszeichen:: + * Notenbezeichnungen in anderen Sprachen:: + @end menu + + @node Absolute Oktavenbezeichnung + @unnumberedsubsubsec Absolute Oktavenbezeichnung + @translationof Absolute octave entry + + @cindex Tonhöhenbezeichnungen + @cindex Absoluter Modus: Tonhöhen + @cindex Absolute Spezifikation von Oktaven + @cindex Angabe der Oktave: absolut + + Tonhöhenbezeichnungen werden durch Kleinbuchstaben + von@tie{}@code{a} bis@tie{}@code{g} angegeben. Dabei + wird ein aus dem Englischen entlehntes Modell benutzt, das sich + vom Deutschen dadurch unterscheidet, dass@tie{}@code{b} + für die Note @qq{H} steht. Die Benutzung deutscher + Notenbezeichnungen mit der Unterscheidung von b und h ist + auch möglich, siehe @ref{Notenbezeichnungen in anderen Sprachen}. + Die Notenbezeichnungen @code{c} bis @code{b} + werden in der Oktave unter dem zweigestrichenen C + gesetzt. + + @c don't use c' here. + @lilypond[verbatim,quote,fragment] + \clef bass + c d e f + g a b c + d e f g + @end lilypond + + @cindex Oktavwechsel: Tonhöhe + @cindex Wechsel der Oktave + @cindex Tonhöhe: Wechsel der Oktave + + @funindex ' + @funindex , + + Andere Oktaven können erreicht werden, indem man ein + Apostroph@tie{}(@code{'}) oder ein Komma@tie{}(@code{,}) + benutzt. Jedes@tie{}@code{'} erhöht die Tonhöhe um + eine Oktave, jedes@tie{}@code{,} erniedrigt sie um eine + Oktave. + + @lilypond[verbatim,quote,fragment] + \clef treble + c' c'' e' g + d'' d' d c + \clef bass + c, c,, e, g + d,, d, d c + @end lilypond + + @seealso + Glossar: + @rglos{Pitch names}. + + Schnipsel: + @rlsr{Pitches}. + + + @node Relative Oktavenbezeichnung + @unnumberedsubsubsec Relative Oktavenbezeichnung + @translationof Relative octave entry + + @cindex Relativ + @cindex Relative Oktavbestimmung + @cindex Oktavbestimmung, relativ + @cindex Noteneingabe: relative Oktavbestimmung + + @funindex \relative + @funindex relative + + Wenn Oktaven im absoluten Modus notiert, passiert es + schnell, eine Note auf der falschen Oktave zu notieren. Mit + dem relativen Modus kommen solche Fehler seltener vor, weil + man die Oktave nur noch sehr selten spezifizieren muss. + Hinzu kommt, dass im absoluten Modus ein einzelner Fehler + schwer zu finden ist, während er im relativen Modus den + ganzen Rest des Stückes um eine Oktave verschiebt. + + @example + \relative @var{Anfangstonhöhe} @var{musikalischer Ausdruck} + @end example + + Im relativen Modus wird angenommen, dass sich jede folgende + Note so dicht wie möglich bei der nächsten befindet. Das bedeutet, + dass die Oktave jeder Tonhöhe innerhalb eines @var{musikalischen + Ausdrucks} wie folgt errechnet wird: + + @itemize + @item + Wenn kein Oktavänderungszeichen an einer Tonhöhe benutzt wird, + wird ihre Oktave so errechnet, dass das Intervall zur vorigen + Noten weniger als eine Quinte ist. Das Intervall wird errechnet, + ohne Versetzungszeichen zu berücksichtigen. + + @item + Ein Oktavänderungszeichen@tie{}@code{'} oder@tie{}@code{,} + kann hinzugefügt werden, um eine Tonhöhe explizit um eine + Oktave zu erhöhen bzw. zu erniedrigen, relativ zu der Tonhöhe, + die ohne das Oktavänderungszeichen errechnet wurde. + + @item + Mehrfache Oktavänderungszeichen können benutzt werden. Die + Zeichen@code{''}@tie{}und@tie{}@code{,,} ändern zum Beispiel + die Tonhöhe um zwei Oktaven. + + @item + Die Tonhöhe der ersten Note ist relativ zu + @code{@var{Anfangstonhöhe}}. Die @var{Anfangstonhöhe} wird + im absoluten Modus gesetzt, und als Empfehlung gilt, eine + Oktave von C zu nehmen. + + @end itemize + + So funktioniert der relative Modus: + + @lilypond[verbatim,quote] + \relative c { + \clef bass + c d e f + g a b c + d e f g + } + @end lilypond + + Oktavversetzungen müssen für alle Intervalle angezeigt werden, + die größer als eine Quarte sind. + + @lilypond[verbatim,quote] + \relative c'' { + c g c f, + c' a, e'' c + } + @end lilypond + + Eine Sequenz ohne ein einziges Oktavänderungszeichen kann + aber trotzdem weite Intervalle umfassen: + + @lilypond[verbatim,quote] + \relative c { + c f b e + a d g c + } + @end lilypond + + Wenn @code{\relative}-Umgebungen geschachtelt werden, gilt + der innerste @code{\relative}-Abschnitt. + + @lilypond[verbatim,quote] + \relative c' { + c d e f + \relative c'' { + c d e f + } + } + @end lilypond + + @code{\relative} hat keine Auswirkung auf @code{\chordmode}-Abschnitte. + + @lilypond[verbatim,quote] + \new Staff { + \relative c''' { + \chordmode { c1 } + } + \chordmode { c1 } + } + @end lilypond + + @code{\relative} darf nicht innerhalb von @code{\chordmode} + notiert werden. + + Tonhöhen innerhalb eines @code{\transpose}-Abschnitts sind absolut, + es sei denn ein @code{\relativ} wird eingefügt. + + @lilypond[verbatim,quote] + \relative c' { + d e + \transpose f g { + d e + \relative c' { + d e + } + } + } + @end lilypond + + @cindex Akkorde und relativer Modus + @cindex relativer Modus und Akkorde + @cindex Oktavenmodus (relativ) und Akkorde + + Wenn der vorherige Ausdruck ein Akkord ist, wird die erste Note + des Akkordes benutzt, um die erste Note des nächsten Akkordes zu + bestimmen. Innerhalb von Akkorden ist die nächste Note immer + relativ zur vorherigen. Betrachten Sie das folgende Beispiel + aufmerksam, insbesondere die @code{c}-Noten. + + @lilypond[verbatim,quote] + \relative c' { + c + + + + } + @end lilypond + + Wie oben erklärt wurde, wird die Oktave einer Tonhöhe nur + nach ihrer Notenbezeichnung errechnet, unabhängig von allen + Versetzungszeichen. Darum wird ein Eisis auf ein H (notiert als @code{b}) + folgend höher gesetzt, während ein Feses tiefer gesetzt wird. + Anders gesagt wird eine doppelterhöhte Quarte wird als + kleineres Intervall angesehen als eine doppelterniedrigte + Quinte, unabhängig von der Anzahl an Halbtönen, die jedes + Intervall enthält. + + @lilypond[verbatim,quote] + \relative c'' { + c2 fis + c2 ges + b2 eisis + b2 feses + } + @end lilypond + + + @seealso -Musickgossar: ++Musikgossar: + @rglos{fifth}, + @rglos{interval}, + @rglos{Pitch names}. + + Notationsreferenz: + @ref{Oktavenüberprüfung}. + + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{RelativeOctaveMusic}. + + + @cindex Relativer Oktavenmodus und Transposition + @cindex Transposition und relativer Modus + + @funindex \transpose + @funindex \chordmode + @funindex \relative + @funindex transpose + @funindex chordmode + @funindex relative + + @knownissues + + @c DEPRECATED + Wenn keine @var{Anfangstonhöhe} für @code{\relative} angegeben + wird, wird@tie{}@code{c'} angenommen. Das ist aber eine + veraltete Option, die in späteren Programmversionen verschwinden kann. + Darum wird von der Benutzung abgeraten. + + + @node Versetzungszeichen + @unnumberedsubsubsec Versetzungszeichen + @translationof Accidentals + + @cindex Versetzungszeichen + @cindex Tonart + @cindex Schlüssel + @cindex Akzidentien + + @warning{Neue Benutzer sind manchmal verwirrt, wie + Versetzungszeichen und Vorzeichen/Tonarten funktionieren. + In LilyPond sind Notenbezeichnungen die wirkliche + Tonhöhe, erst durch Vorzeichen wird bestimmt, wie diese + Tonhöhe dann im Notenbild dargestellt wird. Eine + einfache Tonhöhe wie etwa@tie{}@code{c} bedeutet also + immer das eingestrichene C ohne Versetzungszeichen, egal + was für Vorzeichen/Tonart oder Schlüssel gesetzt sind. + Mehr Information dazu in @rlearning{Versetzungszeichen und Tonartbezeichnung (Vorzeichen)}.} + + @cindex Notenbezeichnungen, Deutsch + @cindex Notenbezeichnungen, Holländisch + @cindex Notenbezeichnungen, Standard + @cindex Versetzungszeichen, Deutsch + @cindex Standardnotenbezeichnungen + @cindex Kreuz + @cindex B + @cindex Doppelkreuz + @cindex Doppel-B + @cindex Auflösungszeichen + @cindex wirkliche Tonhöhe + + + Ein @notation{Kreuz} wird eingegeben, indem man @code{-is} an die + Notenbezeichnung hängt, ein b durch @code{-es}. Doppelkreuze + und Doppel-Bs werden durch Hinzufügen von @code{-isis} und + @code{-eses} hinter die Notenbezeichnung erzeugt. Diese + Syntax leitet sich von den holländischen Notenbezeichnungen + ab. Um andere Bezeichnungen für Versetzungszeichen zu + benutzung, siehe @ref{Notenbezeichnungen in anderen Sprachen}. + + @lilypond[verbatim,quote,relative=2] + ais1 aes aisis aeses + @end lilypond + + @noindent + Auch die deutschen Varianten @code{as} für @code{aes} und + @code{es} für @code{ees} sind erlaubt. Im Unterschied zum + Deutschen ist aber @code{bes} die einzige Version für den Ton + B, während his als @code{bis} geschrieben werden muss. Das kann + aber auch verändert werden, siehe @ref{Notenbezeichnungen in anderen Sprachen}. + + + @lilypond[verbatim,quote,relative=2] + a4 aes a2 + @end lilypond + + Ein Auflösungszeichen macht die Wirkung eines Kreuzes oder Bs + rückgängig. Diese Auflösungszeichen werden jedoch nicht + als Suffix einer Tonhöhenbezeichnung eingegeben, sondern + sie ergeben sich (automatisch) aus dem Kontext, wenn die + nicht alterierte Notenbezeichnung eingegeben wird. + + @lilypond[quote,ragged-right,fragment,verbatim,relative=2] + a4 aes a2 + @end lilypond + + + @cindex Vierteltöne + @cindex Vorzeichen, Vierteltöne + @cindex Versetzungszeichen, Vierteltöne + @cindex Mikrotöne + @cindex Halbkreuz + @cindex Halb-B + + Versetzungszeichen für Vierteltöne werden durch Anhängen der Endungen + @code{-eh} (Erniedrigung) und @code{-ih} (Erhöhung) an den + Tonhöhenbuchstaben erstellt. Das Beispiel zeigt eine in Vierteltönen + aufsteigende Serie vom eingestrichenen C. + + @lilypond[verbatim,quote,relative=2] + ceseh1 ces ceh c cih cis cisih + @end lilypond + + + @cindex Versetzungszeichen, Erinnerung + @cindex Versetzungszeichen, Warnung + @cindex Vorzeichen, Erinnerung + @cindex Vorzeichen in Klammern + @cindex Erinnerungsvorzeichen + @cindex Warnungsvorzeichen + @cindex Klammern um Vorzeichen + + @funindex ? + @funindex ! + + Normalerweise werden Versetzungszeichen automatisch gesetzt, aber + sie können auch manuell hinzugefügt werden. Ein erinnerndes + Versetzungszeichen kann erzwungen werden, indem man ein Ausrufungszeichen + (@code{!}) hinter die Notenbezeichnung schreibt. Ein warnendes + Versetzungszeichen (also ein Vorzeichen in Klammern) wird durch Anfügen + eines Fragezeichens (@code{?}) erstellt. Mit diesen zusätzlichen + Zeichen kann man sich auch Auflösungszeichen ausgeben lassen. + + @lilypond[quote,ragged-right,fragment,verbatim,relative=1] + cis cis cis! cis? c c? c! c + @end lilypond + + @cindex Versetzungszeichen an übergebundener Note + @cindex Überbindung, Versetzungszeichen + + Versetzungzeichen von übergebundenen Noten werden nur + dann gesetzt, wenn ein neues System begonnen wird: + + @lilypond[verbatim,quote,relative=2] + cis1 ~ cis ~ + \break + cis + @end lilypond + + @snippets + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {preventing-extra-naturals-from-being-automatically-added.ly} + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {makam-example.ly} + + @seealso + Glossar: + @rglos{sharp}, + @rglos{flat}, + @rglos{double sharp}, + @rglos{double flat}, + @rglos{Pitch names}, + @rglos{quarter tone}. + + Handbuch zum Lernen: + @rlearning{Versetzungszeichen und Tonartbezeichnung (Vorzeichen)}. + + Notationsreferenz: + @ref{Automatische Versetzungszeichen}, + @ref{Vorgeschlagene Versetzungszeichen (musica ficta)}, + @ref{Notenbezeichnungen in anderen Sprachen}. + + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{Accidental_engraver}, + @rinternals{Accidental}, + @rinternals{AccidentalCautionary}, + @rinternals{accidental-interface}. + + + @cindex Versetzungszeichen, Viertelton + @cindex Vierteltonversetzungszeichen + + @knownissues + + Es gibt keine allgemeinen Regeln für die Notation von + Vierteltönen, die Symbole von LilyPond folgen also + keinem Standard. + + + @node Notenbezeichnungen in anderen Sprachen + @unnumberedsubsubsec Notenbezeichnungen in anderen Sprachen + @translationof Note names in other languages + + @cindex Notenbezeichungen, andere Sprachen + @cindex Tonhöhenbezeichnungen, andere Sprachen + @cindex Sprache, Tonhöhenbezeichnungn in anderer + + Es gibt vordefinierte Bezeichnungen für die Notenbezeichnungen in anderen + Sprachen als Englisch. Um sie zu benutzen, muss nur die + entsprechende Datei für die jeweilige Sprache eingefügt werden. + Zum Beispiel fügt man mit @code{@w{\include "deutsch.ly"}} die + Notendefinitionen für die deutsche Sprache am Anfang der Datei + hinzu + + @warning{Weil in einigen @code{\include}-Dateien (wie + beispielsweise @code{@w{predefined-fretboards.ly}}) die niederländischen + (Standard-)Notenbezeichnungen benutzt werden, muss der + @code{@bs{}include}-Befehl für die Sprachdatei nach allen + anderen LilyPond-eigenen Dateien gesetzt werden.} + + In der Tabelle sind die existierenden Sprachdefinitionen + mit den dazugehörigen Notenbezeichnungen dargestellt. + + @quotation + @multitable {@file{nederlands.ly}} {do re mi fa sol la sib si} + @headitem Sprachdatei + @tab Notenbezeichnung + @item @file{nederlands.ly} + @tab c d e f g a bes b + @item @file{arabic.ly} + @tab do re mi fa sol la sib si + @item @file{catalan.ly} + @tab do re mi fa sol la sib si + @item @file{deutsch.ly} + @tab c d e f g a b h + @item @file{english.ly} + @tab c d e f g a bf b + @item @file{espanol.ly} + @tab do re mi fa sol la sib si + @item @file{italiano.ly} + @tab do re mi fa sol la sib si + @item @file{norsk.ly} + @tab c d e f g a b h + @item @file{portugues.ly} + @tab do re mi fa sol la sib si + @item @file{suomi.ly} + @tab c d e f g a b h + @item @file{svenska.ly} + @tab c d e f g a b h + @item @file{vlaams.ly} + @tab do re mi fa sol la sib si + @end multitable + @end quotation + + @noindent + und die dazugehörigen Versetzungszeichen-Endungen: + + @quotation + @multitable {@file{nederlands.ly}} {-s/-sharp} {-ess/-es} {-ss/-x/-sharpsharp} {-essess/-eses} + @headitem Sprachdatei + @tab Kreuz @tab B @tab Doppelkreuz @tab Doppel-B + @item @file{nederlands.ly} + @tab -is @tab -es @tab -isis @tab -eses + @item @file{arabic.ly} + @tab -d @tab -b @tab -dd @tab -bb + @item @file{catalan.ly} + @tab -d/-s @tab -b @tab -dd/-ss @tab -bb + @item @file{deutsch.ly} + @tab -is @tab -es @tab -isis @tab -eses + @item @file{english.ly} + @tab -s/-sharp @tab -f/-flat @tab -ss/-x/-sharpsharp + @tab -ff/-flatflat + @item @file{espanol.ly} + @tab -s @tab -b @tab -ss @tab -bb + @item @file{italiano.ly} + @tab -d @tab -b @tab -dd @tab -bb + @item @file{norsk.ly} + @tab -iss/-is @tab -ess/-es @tab -ississ/-isis + @tab -essess/-eses + @item @file{portugues.ly} + @tab -s @tab -b @tab -ss @tab -bb + @item @file{suomi.ly} + @tab -is @tab -es @tab -isis @tab -eses + @item @file{svenska.ly} + @tab -iss @tab -ess @tab -ississ @tab -essess + @item @file{vlaams.ly} + @tab -k @tab -b @tab -kk @tab -bb + @end multitable + @end quotation + + @noindent + Auf Holländisch, Deutsch, Norwegisch und Schwedisch (u. a.) werden die + Erniedrigungen von @q{a} wie @code{aes} und @code{aeses} zu + @code{as} und @code{ases} (oder auch @code{asas}) zusammengezogen. + In manchen Sprachen sind nur diese Kurzformen definiert. + + @lilypond[verbatim,quote,relative=2] + a2 as e es a ases e eses + @end lilypond + + + @cindex Mikrotöne + @cindex Halbkreuz + @cindex Halb-B + @cindex sesqui-Kreuz + @cindex sesqui-B + + Bestimmte Musik verwendet Alterationen, die Bruchteile von den + @qq{normalen} Kreuzen oder Bs sind. Die Notenbezeichnungen für + Vierteltöne für die verschiedenen Sprachen sind in der folgenden + Tabelle aufgeführt. Die Präfixe @qq{Semi-} und @qq{Sesqui-} bedeuten + @qq{halb} bzw. @qq{eineinhalb}. Für alle anderen + Sprachen sind noch keine eigenen Namen definiert. + + @quotation + @multitable {@file{nederlands.ly}} {@b{semi-sharp}} {@b{semi-flat}} {@b{sesqui-sharp}} {@b{sesqui-flat}} + @headitem Sprachdatei + @tab Vierteltonkreuz @tab Viertelton-B @tab 3/4-tonkreuz @tab 3/4-ton-B + + @item @file{nederlands.ly} + @tab -ih @tab -eh @tab -isih @tab -eseh + @item @file{arabic.ly} + @tab -sd @tab -sb @tab -dsd @tab -bsb + @item @file{deutsch.ly} + @tab -ih @tab -eh @tab -isih @tab -eseh + @item @file{english.ly} + @tab -qs @tab -qf @tab -tqs @tab -tqf + @item @file{italiano.ly} + @tab -sd @tab -sb @tab -dsd @tab -bsb + @item @file{portugues.ly} + @tab -sqt @tab -bqt @tab -stqt @tab -btqt + @end multitable + @end quotation + + + @seealso + Glossar: + @rglos{Pitch names}. + + Schnipsel: + @rlsr{Pitches}. + + + @node Viele Tonhöhen gleichzeitig verändern + @subsection Viele Tonhöhen gleichzeitig verändern + @translationof Changing multiple pitches + + Dieser Abschnitt zeigt, wie man Tonhöhen beeinflusst. + + @menu + * Oktavenüberprüfung:: + * Transposition:: + @end menu + + @node Oktavenüberprüfung + @unnumberedsubsubsec Oktavenüberprüfung + @translationof Octave checks + + @cindex Oktavenüberprüfung + @cindex Oktavierungskorrektur + @cindex Kontroll-Tonhöhe + + @funindex = + @funindex \octaveCheck + @funindex octaveCheck + @funindex controlpitch + + Im relativen Modus geschieht es recht häufig, dass ein + Oktavänderungszeichen vergessen wird. Oktavenüberprüfungen + machen es einfacher, solche Fehler zu entdecken und zu + korrigieren. Sie geben eine Warnung aus und korrigieren + die Oktave, wenn eine Note in einer unerwarteten Oktave + gefunden wird. + + Um die Oktave einer Note zu überprfüfen, muss die absolute + Oktave nach dem @code{=}-Symbol angegeben werden. Im + folgenden Beispiel wird eine Warnung (und eine Tonhöhenänderung) + generiert, weil die zweite Note als absolute Oktave + ein @code{d''} anstelle von @code{d'} notiert ist, + wie es die Oktavierungskorrektur markiert. + + @lilypond[verbatim,quote] + \relative c'' { + c2 d='4 d + e2 f + } + @end lilypond + + Die Oktave von einer Note kann auch mit dem + @code{\octaveCheck}@tie{}@var{Kontrolltonhöhe}-Befehl + überprüft werden. @var{Kontrollhöhe} wird im absoluten + Modus eingegeben. Dabei wird überprüft, ob das + Intervall zwischen der vorherigen Note und der + @var{Kontrolltonhöhe} nicht größer als eine Quarte ist + (die normale Berechnung im relativen Modus). Wenn diese + Überprüfung einen Fehler ausgibt, wird eine Warnung + gemeldet, aber die vorigen Note wird nicht verändert. + Folgende Noten sind dann relativ zur @var{Kontrolltonhöhe}. + + @lilypond[verbatim,quote] + \relative c'' { + c2 d + \octaveCheck c' + e2 f + } + @end lilypond + + Vergleichen Sie die zwei Takte im nächsten Beispiel. Die + erste und dritte @code{\octaveCheck}-Überprüfung gibt + einen Fehler aus, die zweite dagegen ist erfolgreich: + + @lilypond[verbatim,quote] + \relative c'' { + c4 f g f + + c4 + \octaveCheck c' + f + \octaveCheck c' + g + \octaveCheck c' + f + } + @end lilypond + + @seealso + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{RelativeOctaveCheck}. + + + @node Transposition + @unnumberedsubsubsec Transposition + @translationof Transpose + + @cindex Transposition + @cindex Transponieren + @cindex Noten, transponieren + @cindex Tonhöhen, transponieren + + @funindex \transpose + @funindex transpose + + Ein musikalischer Ausdruck kann mit dem Befehl @code{\transpose} + transponiert werden. Die Syntax lautet: + + @example + \transpose @var{vonTonhöhe} @var{nachTonhöhe} @var{mus. Ausdruck} + @end example + + @noindent + Das bedeutet, dass der @var{mus. Ausdruck} um das Intervall zwischen den + Tonhöhen @var{vonTonhöhe} und @var{nachTonhöhe} transponiert wird: Jede Note, die die + Tonhöhe @var{vonTonhöhe} hat, wird in die Tonhöhe @var{nachTonhöhe} umgewandelt, und alle anderen + Noten um das gleiche Intervall. Beide Tonhöhen + werden im absoluten Modus eingegeben. + + @warning{Tonhöhen innerhalb einer @code{@bs{}transpose}-Umgebung + sind absolut, es sei denn, ein @code{@bs{}relative} wird + eingefügt.} + + So kann z. B. ein Stück in D-Dur, wenn es für den Sänger etwas zu + tief ist, nach E-Dur transponiert werden. Dabei + werden auch die Vorzeichen entsprechend angepasst: + + @lilypond[verbatim,quote] + \transpose d e { + \relative c' { + \key d \major + d4 fis a d + } + } + @end lilypond + + Wenn eine Stimme, die in C notiert ist, von einer A-Klarinette + gespielt werden soll (für die A als C notiert wird, + aber eine kleine Terz tiefer erklingt als es notiert + ist), kann die entpsrechende Stimme wie folgt erstellt + werden: + + @lilypond[verbatim,quote] + \transpose a c' { + \relative c' { + \key c \major + c4 d e g + } + } + @end lilypond + + @noindent + Beachten Sie, dass @w{@code{\key c \major}} explizit + angegeben werden muss. Wenn hier keine Tonart angemerkt + würde, würde die Noten zwar transponiert, aber keine + Vorzeichen angezeigt werden. + + @code{\transpose} unterscheidet enharmonische Verwechslungen: sowohl + @w{@code{\transpose c cis}} als auch @w{@code{\transpose c des}} transponieren + die Musik einen Halbton nach oben. Aber die erste Version gibt als + Versetzungszeichen Kreuze aus, die zweite dagegen B-Versetzungszeichen. + + @lilypond[verbatim,quote] + music = \relative c' { c d e f } + \new Staff { + \transpose c cis { \music } + \transpose c des { \music } + } + @end lilypond + + @cindex transponierende Instrumente + @cindex Instrumente, transponierende + + @code{\transpose} kann auch benutzt werden, um die geschriebenen + Noten eines transponierenden Instruments zu notieren. Im vorigen Beispiel wurde die Tonhöhen so eingegeben, + wie sie erklingen (also in C), aber man kann genauso + gut auch andersherum aus einer Stimme, die für ein + transponierendes Instrument in einem anderen Ton als + C geschrieben wurde, eine Partitur in C erstellen. + Die Noten einer B-Trompete, die mit einem notierten E + (also einem klingenden D) anfangen, könnte man also + auch so eingeben: + + @example + musicInBflat = @{ e4 @dots{} @} + \transpose c bes, \musicInBflat + @end example + + @noindent + Um die Noten dann in F zu setzen (um sie etwa für ein + Horn zu arrangieren), könnte man die schon geschriebenen + Noten wieder mit einem weiteren @code{\transpose} + umgeben: + + @example + musicInBflat = @{ e4 @dots{} @} + \transpose f c' @{ \transpose c bes, \musicInBflat @} + @end example + + @noindent + Für mehr Information zu transponierenden Instrumenten + siehe auch @ref{Transposition von Instrumenten}. + + @snippets + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {transposing-pitches-with-minimum-accidentals-smart-transpose.ly} + + @seealso + Notationsreferenz: + @ref{Relative Oktavenbezeichnung}, + @ref{Transposition von Instrumenten}. + + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{TransposedMusic}. + + @funindex \transpose + @funindex \chordmode + @funindex \relative + @funindex transpose + @funindex chordmode + @funindex relative + + @knownissues + + Der relative Modus wirkt nicht in @code{\transpose}, + @code{\chordmode} oder @code{\relative}. + Um auch im relativen Modus transponieren + zu können, muss ein @code{\relative} innerhalb des + @code{\tranpose} zusätzlich gesetzt werden. + + + @node Tonhöhen anzeigen lassen + @subsection Tonhöhen anzeigen lassen + @translationof Displaying pitches + + Dieser Abschnitt zeigt, wie die Ausgabe von Tonhöhen + verändern werden kann. + + @menu + * Notenschlüssel:: + * Tonartbezeichnung:: + * Oktavierungsklammern:: + * Transposition von Instrumenten:: + * Automatische Versetzungszeichen:: + * Tonumfang:: + @end menu + + @node Notenschlüssel + @unnumberedsubsubsec Notenschlüssel + @translationof Clef + + @cindex G-Schlüssel + @cindex C-Schlüssel + @cindex F-Schlüssel + @cindex Sopranschlüssel + @cindex Violinschlüssel + @cindex Altschlüssel + @cindex Bratschenschlüssel + @cindex Tenorschlüssel + @cindex Bassschlüssel + @cindex Französischer Violinschlüssel + @cindex Mezzosopranschlüssel + @cindex Sopranschlüssel in C + @cindex Baritonschlüssel + @cindex Subbassschlüssel + @cindex Schlüssel + @cindex Notenschlüssel + @cindex Alte Schlüssel + @cindex Schlüssel Alter Musik + @cindex Schlüssel, C + @cindex Schlüssel, G + @cindex Schlüssel, F + + @funindex \clef + @funindex clef + + Der Schlüssel kann verändert werden. Das eingestrichene + C wird in jedem Beispiel gezeigt: + + @lilypond[verbatim,quote,relative=1] + \clef treble + c2 c + \clef alto + c2 c + \clef tenor + c2 c + \clef bass + c2 c + @end lilypond + + Andere Schlüssel sind u. A.: + + @lilypond[verbatim,quote,relative=1] + \clef french + c2 c + \clef soprano + c2 c + \clef mezzosoprano + c2 c + \clef baritone + c2 c + + \break + + \clef varbaritone + c2 c + \clef subbass + c2 c + \clef percussion + c2 c + \clef tab + c2 c + @end lilypond + + Weitere unterstützte Schlüssel sind beschrieben in @ref{Mensurale Schlüssel} + und @ref{Gregorianische Schlüssel}. + + @cindex transponierende Schlüssel + @cindex Schlüssel, transponierend + @cindex Oktavtransposition + @cindex Chor-Tenorschlüssel + @cindex Tenorschlüssel, Chor + + Indem @code{_8} oder @code{^8} an die jeweilige Schlüsselbezeichnung + angehängt wird, wird der Schlüssel um eine Oktave nach oben oder unten + transponiert, mit @code{_15} oder @code{^15} um zwei Oktaven. + Die Schlüsselbezeichnung muss in Anführungszeichen gesetzt werden, + wenn sie Unterstriche oder Zahlen enthält, siehe Beispiel: + + @lilypond[verbatim,quote,relative=2] + \clef treble + c2 c + \clef "treble_8" + c2 c + \clef "bass^15" + c2 c + @end lilypond + + @snippets + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {tweaking-clef-properties.ly} + + + @seealso + Notationsreferenz: + @ref{Mensurale Schlüssel}, @ref{Gregorianische Schlüssel}. + + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{Clef_engraver}, + @rinternals{Clef}, + @rinternals{OctavateEight}, + @rinternals{clef-interface}. + + + @node Tonartbezeichnung + @unnumberedsubsubsec Tonartbezeichnung + @translationof Key signature + + @cindex Tonart + @cindex Vorzeichen + + @funindex \key + @funindex key + + @c duplicated in Key signature and Accidentals + @warning{Neue Benutzer sind manchmal verwirrt, wie + Versetzungszeichen und Vorzeichen/Tonarten funktionieren. + In LilyPond sind Notenbezeichnungen die wirkliche + Tonhöhe, erst durch Vorzeichen wird bestimmt, wie diese + Tonhöhe dann im Notenbild dargestellt wird. Eine + einfache Tonhöhe wie etwa@tie{}@code{c} bedeutet also + immer das eingestrichene C ohne Versetzungszeichen, egal + was für Vorzeichen/Tonart oder Schlüssel gesetzt sind. + Mehr Information dazu in @rlearning{Versetzungszeichen und Tonartbezeichnung (Vorzeichen)}.} + + Die Vorzeichen zeigen die Tonart an, in welcher ein Stück notiert ist. + Es handelt sich um eine Anzahl von Alterationszeichen (Kreuzen oder + Bs) am Beginn jedes Notensystems. + + Die Tonart kann geändert werden: + + @example + @code{\key} @var{Tonhöhe} @var{Modus} + @end example + + @funindex \minor + @funindex \major + @funindex \minor + @funindex \ionian + @funindex \locrian + @funindex \aeolian + @funindex \mixolydian + @funindex \lydian + @funindex \phrygian + @funindex \dorian + @funindex minor + @funindex major + @funindex minor + @funindex ionian + @funindex locrian + @funindex aeolian + @funindex mixolydian + @funindex lydian + @funindex phrygian + @funindex dorian + + @cindex Kirchentonarten + @cindex Modus + @cindex Dur + @cindex Moll + @cindex Ionisch + @cindex Lokrisch + @cindex Äolisch + @cindex Mixolydisch + @cindex Aeolisch + @cindex Dorisch + @cindex Lydisch + @cindex Phrygisch + + Der Wert @var{Modus} sollte entweder @code{\major} oder @code{\minor} + sein, um Moll oder Dur der @var{Tonhöhe} zu erhalten. Es können auch + Modusbezeichnungen für Kirchentonarten verwendet werden: @code{\ionian} + (Ionisch), @code{\locrian} (Locrisch), @code{\aeolian} (Aeolisch), + @code{\mixolydian} (Mixolydisch), @code{\lydian} (Lydisch), + @code{\phrygian} (Phrygisch) und @code{\dorian} (Dorisch). + + @lilypond[verbatim,quote,relative=2] + \key g \major + fis1 + f + fis + @end lilypond + + @snippets + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {preventing-natural-signs-from-being-printed-when-the-key-signature-changes.ly} + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {non-traditional-key-signatures.ly} + + + @seealso + Glossar: + @rglos{church mode}, + @rglos{scordatura}. + + Handbuch zum Lernen: + @rlearning{Versetzungszeichen und Tonartbezeichnung (Vorzeichen)}. + + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{KeyChangeEvent}, + @rinternals{Key_engraver}, + @rinternals{Key_performer}, + @rinternals{KeyCancellation}, + @rinternals{KeySignature}, + @rinternals{key-cancellation-interface}, + @rinternals{key-signature-interface}. + + + @node Oktavierungsklammern + @unnumberedsubsubsec Oktavierungsklammern + @translationof Ottava brackets + + @cindex ottava + @cindex 15ma + @cindex 8va + @cindex 8ve + @cindex Oktavierung + + @funindex set-octavation + @funindex \ottava + @funindex ottava + + @notation{Oktavierungsklammern} zeigen eine zusätzliche + Transposition von einer Oktave an: + + @lilypond[verbatim,quote,relative=2] + a'2 b + \ottava #1 + a b + \ottava #0 + a b + @end lilypond + + Die @code{ottava}-(Oktavierungs)-Funktion kann auch die + Werte -1 (für 8va bassa), + 2@tie{}(für 15ma), und -2 (für 15ma bassa) als Argumente + haben. + + + @snippets + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {ottava-text.ly} + + + @seealso + Glossar: + @rglos{octavation}. + + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{Ottava_spanner_engraver}, + @rinternals{OttavaBracket}, + @rinternals{ottava-bracket-interface}. + + + @node Transposition von Instrumenten + @unnumberedsubsubsec Transposition von Instrumenten + @translationof Instrument transpositions + + @cindex Transposition, MIDI + @cindex Transposition, Instrumente + @cindex Transponierendes Instrument + @cindex MIDI + @cindex MIDI-Transposition + + @funindex \transposition + @funindex transposition + + Wenn man Noten setzt, die von transponierenden Instrumenten + gespielt werden, sind oft einige Stimmen auf einer + anderen Tonhöhe notiert als dem Kammerton. In diesem + Fall muss die Tonart des transponierenden Instruments + gekennzeichnet werden, weil sonst die MIDI-Ausgabe + und Stichnoten in anderen Stimmen falsche Tonhöhen + produzieren. Mehr Information zu Stichnoten in + @ref{Stichnoten}. + + @example + \transposition @var{Tonhöhe} + @end example + + Die Tonhöhe, die für @code{\transposition} benutzt + wird, muss mit dem wirklichen Ton übereinstimmen, + der erklingt, wenn das Instrument ein @code{c'} + in seiner Stimme spielt. Die Tonhöhe wird im + absoluten Modus angegeben, ein Instrument also, + dass einen Ton höher erklingt als es notiert wird, + muss folgenden Befehl benutzen: + @w{@code{\transposition d'}}. @code{\transposition} + sollte @emph{nur} dann benutzt werden, wenn sie nicht + @emph{nicht} in C notiert werden. + + Hier einige Noten für Geige und B-Klarinette: die + Stimmen (Noten und Vorzeichen) sind so notiert, wie sie + in der Partitur erscheinen. Die zwei Instrumente + spielen unisono. + + @lilypond[verbatim,quote] + \new GrandStaff << + \new Staff = "violin" { + \relative c'' { + \set Staff.instrumentName = #"Vln" + \set Staff.midiInstrument = #"violin" + % not strictly necessary, but a good reminder + \transposition c' + + \key c \major + g4( c8) r c r c4 + } + } + \new Staff = "clarinet" { + \relative c'' { + \set Staff.instrumentName = \markup { Cl (B\flat) } + \set Staff.midiInstrument = #"clarinet" + \transposition bes + + \key d \major + a4( d8) r d r d4 + } + } + >> + @end lilypond + + Die @code{\transposition} kann während eines Stückes + geändert werden. Ein Klarinetist zum Beispiel kann + zwischen B- und A-Klarinette wechseln. + + @lilypond[verbatim,quote,relative=2] + \set Staff.instrumentName = #"Cl (A)" + \key a \major + \transposition a + c d e f + \textLengthOn + s1*0^\markup { Switch to B\flat clarinet } + R1 + + \key bes \major + \transposition bes + c2 g + @end lilypond + + + @seealso + Glossar: + @rglos{concert pitch}, + @rglos{transposing instrument}. + + Notationsreferenz: + @ref{Stichnoten}, @ref{Transposition}. + + Schnipsel: + @rlsr{Pitches}. + + + @node Automatische Versetzungszeichen + @unnumberedsubsubsec Automatische Versetzungszeichen + @translationof Automatic accidentals + + @cindex Akzidentien + @cindex Versetzungszeichen, Standard + @cindex Versetzungszeichenstil + @cindex Automatische Versetzungszeichen + @cindex Versetzungszeichen, automatisch + @cindex Standard-Versetzungszeichenstil + + @funindex set-accidental-style + @funindex voice + @funindex default + + Es gibt viele unterschiedliche Regeln, wie Versetzungszeichen + notiert werden. LilyPond hat eine Funktion, mit der + spezifiziert werden kann, welcher Stil benutzt werden + soll. Diese Funktion kann man wie folgt benutzen: + + @example + \new Staff << + #(set-accidental-style 'voice) + @{ @dots{} @} + >> + @end example + + Der Versetzungszeichenstil bezieht sich auf das aktuelle + Notensystem in der Standardeinstellung (eine Ausnahme + bilden die Stile @code{piano} und @code{piano-cautionary}, + die weiter unten erklärt werden). Die Funktion kann aber + auch ein zweites Argument erhalten, mit der spezifiziert + wird, auf welchen Bereich sich der neue Stil erstreckt. + Um etwa den neuen Stil in allen Systemen einer + Stimmbruppe (@code{StaffGroup}) zu benutzen, müsste der Befehl so aussehen: + + @example + #(set-accidental-style 'voice 'StaffGroup) + @end example + + Folgende Versetzungszeichenstile sind unterstützt. + Um jeden Stil zu erklären, wird folgendes Beispiel + benützt: + + @lilypond[verbatim,quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'default) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'default) + \musicB + } + >> + } + @end lilypond + + Die letzten Zeilen des Beispiels könnten auch mit folgendem + Code ersetzt werden, solange der gleiche Versetzungszeichenstil + in beiden Systemen benutzt werden soll: + + @example + \new PianoStaff @{ + << + \context Staff = "up" @{ + %%% change the next line as desired: + #(set-accidental-style 'default 'Score) + \musicA + @} + \context Staff = "down" @{ + \musicB + @} + >> + @} + @end example + + + @c don't use verbatim in this table. + @table @code + @item default (Standard) + + @cindex Standard-Versetzungszeichenstil + @cindex Versetzungszeichenstil, Standard + + Das ist das Standardverhalten. Es entspricht der + Konvention für Notation von Musik des 18. Jahrhunderts: + Versetzungszeichen werden bis zum Taktende erinnert, in + dem sie gesetzt wurden, und nur in ihrer eigenen + Oktave. Im nächsten Beispiel wird also kein + Auslösungszeichen vor dem@tie{}@code{b} (H) im zweiten + Takt oder dem letzen@tie{}@code{c} gesetzt: + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'default) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'default) + \musicB + } + >> + } + @end lilypond + + @item voice (Stimme) + + @cindex Versetzungszeichenstil, Stimme + @cindex Stimme-Versetzungszeichenstil + @cindex Voice-Versetzungszeichenstil + @cindex moderner Versetzungszeichenstil + @cindex Versetzungszeichenstil modern + @cindex Versetzungszeichenstil, modern-cautionary + @cindex modern-Warnung-Versetzungszeichenstil + + @funindex voice + + Das normale Verhalten ist es, die Versetzungszeichen + auf der Notensystemebene zu erinnern. In diesem + Stil aber werden Versetzungszeichen individuell für + jede Stimme errechnet. Abgesehen davon gelten die + Regeln des Standardstiles (@code{default}). + + Das hat zur Folge, dass Versetzungszeichen von einer + Stimme in der anderen nicht aufgelöst werden, was oft + ein unerwünschtes Ergebnis ist: im folgenden Beispiel + kann man schwer sagen, ob das zweite @code{a} unalteriert + oder erhöht gespielt werden soll. Die @code{voice}-Option + sollte also nur benutzt werden, wenn die Stimmen + separat von unterschiedlichen Musikern gelesen werden. + Wenn das System nur von einem Musiker benutzt wird + (etwa der Dirigent oder ein Klavierspieler), dann + sind die Stile @code{modern} oder @code{modern-cautionary} + besser. + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'voice) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'voice) + \musicB + } + >> + } + @end lilypond + + @item modern (Modern) + + @cindex Versetzungszeichen, moderne Stile + @cindex Moderner Stil, Versetzungszeichen + + @funindex modern + + Dieser Stil orientiert sich an den üblichen Regeln für + das 20. Jahrhundert. Die gleichen Versetzungszeichen + wie im Standardstil werden gesetzt, allerdings mit zwei + Ausnahmen, die Uneindeutigkeiten verhindern sollen: nach + vorübergehenden Versetzungszeichen werden Auflösungszeichen + auch im folgenden Takt gesetzt (für Noten innerhalb der + selben Oktave) und im gleichen Takt für Noten in + unterschiedlichen Oktaven. Daher kommen also die Auflösungszeichen + vor dem H und dem C im zweiten Takt des oberen Systems: + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'modern) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'modern) + \musicB + } + >> + } + @end lilypond + + @item modern-cautionary (Modern mit Warnungen) + + @cindex Versetzungszeichen, moderner Stil mit Warnungen + @cindex moderner Versetzungszeichenstil + @cindex moderner Verseztungszeichenstil mit Warnungen + + @funindex modern-cautionary + + Dieser Stil ähnelt @code{modern}, aber die @qq{zusätzlichen} + Versetzungszeichen (die normalerweise nicht gesetzt werden) + werden als Warnungen gesetzt. In der Standardeinstellung werden + sie in Klammern gesetzt, aber sie können auch in kleinerer + Größe gesetzt werden, wenn man die @code{cautionary-style}-Eigenschaft + von @code{AccidentalSuggestion} definiert. + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'modern-cautionary) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'modern-cautionary) + \musicB + } + >> + } + @end lilypond + + @item modern-voice (Modern für Stimmeen) + + @cindex Versetzungszeichenstil, modern + @cindex Versetzungszeichen pro Stimme + @cindex moderner Versetzungszeichenstil + @cindex moderne Versetzungszeichen + @cindex Stimmen, Versetzungszeichen für + + @funindex modern-voice + + Diese Regel wird für vielstimmige Noten benutzt, die sowohl von + unterschiedlichen Spielern für jede Stimme als auch von einem Spieler + für alle Stimmen benutzt. Versetzungszeichen werden für jede + Stimme gesetzt, aber sie @emph{werden} über die Stimme hinweg + aufgelöst innerhalb des selben Notensystems. Das @code{a} im letzten + Takt ist also aufgelöst, weil die vorigen Auflösung in einer anderen + Stimme stattgefunden hatte, und das @code{d} im unteren System ist + aufgelöst wegen eines Versetzunszeichens in einer anderen Stimme im + vorigen Takt: + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'modern-voice) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'modern-voice) + \musicB + } + >> + } + @end lilypond + + @cindex Versetzungszeichenstil, modern mit Warnung für Stimmen + @cindex Stimmen, Versetzungszeichenstil mit Warnung für Stimmen + @cindex moderner Versetzungszeichensitl mit Warnungen für Stimmen + + @funindex modern-voice-cautionary + + @item modern-voice-cautionary (modern mit Warnungen für einzelne Stimmen) + + Dieser Stil ist der gleiche wie @code{modern-voice}, nur dass hier + die zusätzlichen Versetzungszeichen (die nicht vom @code{voice}-Stil + gesetzt werden) als Warnungsversetzungszeichen gesetzt werden. + Obwohl alle Versetzungszeichen, die mit @code{default} gesetzt werden, + auch mit diesem Stil gesetzt werden, sind manche Warnungsversetzungszeichen. + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'modern-voice-cautionary) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'modern-voice-cautionary) + \musicB + } + >> + } + @end lilypond + + @item piano (Klavier) + + @cindex Versetzungszeichenstil, piano + @cindex Versetzungszeichen für Klavier + @cindex Klavier-Versetzungszeichenstil + @cindex Piano-Versetzungszeichenstil + + @funindex piano + + Dieser Stil orientiert sich an den Regeln im 20. Jahrhundert für die + Notation von Klaviermusik. Er ist sehr ähnlich mit dem modernen + Stil, aber Versetzungszeichen werden auch über Notensysteme hinweg + für die selbe Akkolade (@code{GrandStaff} oder @code{PianoStaff}) aufgelöst. + + Dieser Versetzungszeichenstil wirkt sich standardmäßig auf die gesamte + Akkolade (@code{GrandStaff} oder @code{PianoStaff}) aus. + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'piano) + \musicA + } + \context Staff = "down" { + \musicB + } + >> + } + @end lilypond + + @item piano-cautionary (Klavier mit Warnungen) + + @funindex piano-cautionary + + @cindex Versetzungszeichen, piano cautionary + @cindex Warnungsversetzungszeichen für Klavier + @cindex Klavier: Warnungsversetzungszeichen + @cindex Versetzungszeichenstil Klavier mit Warnungen + + Dieser Stil verhält sich wie @code{piano}, aber die zusätzlichen + Versetzungszeichen werden als Warnungen ausgegeben: + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'piano-cautionary) + \musicA + } + \context Staff = "down" { + \musicB + } + >> + } + @end lilypond + + + @item neo-modern + + @funindex neo-modern + + @cindex neo-moderner Versetzungszeichenstil + @cindex Versetzungszeichenstil, neo-modern + + Dieser Stil richtet sich nach den Regeln für moderne Musik: + Versetzungszeichen werden mit im @code{modern}-Stil gesetzt, aber + sie werden nochmal gesetzt, wenn die gleiche Note später im selben + Takt auftritt -- außer die Note wird unmittelbar wiederholt. + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'neo-modern) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'neo-modern) + \musicB + } + >> + } + @end lilypond + + @item neo-modern-cautionary (neo-modern mit Warnungen) + + @funindex neo-modern-cautionary + + @cindex neo-modern-cautionary-Versetzungszeichenstil + @cindex Versetzungszeichenstil neo-modern mit Warnungen + @cindex Warnungsversetzungszeichen, neo-modern + + Dieser Stil ähnelt @code{neo-modern}, aber die zusätzlichen + Versetzungszeichen werden als Warnungen gesetzt. + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'neo-modern-cautionary) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'neo-modern-cautionary) + \musicB + } + >> + } + @end lilypond + + + @item dodecaphonic (Zwölftonmusik) + + @funindex dodecaphonic + + @cindex dodekaphoner Versetzungszeichenstil + @cindex Zwölftonmusik, Versetzungszeichenstil + @cindex Versetzungszeichenstil, Zwölftonmusik + + Dieser Stil orientiert sich an der Notation von sog. Zwölftonmusik, + der Stil wurde Anfang des 20. Jahrhunderts in Gebrauch genommen. + In diesem Stil erhält @emph{jede} Note ein Versetzungszeichen, wozu + auch Auflösungszeichen zählen. + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'dodecaphonic) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'dodecaphonic) + \musicB + } + >> + } + @end lilypond + + + @item teaching (didaktisch) + + @funindex teaching + + @cindex teaching-Versetzungszeichenstil + @cindex Versetzungszeichenstil teaching + @cindex didaktischer Versetzungszeichenstil + + Dieser Stil ist für Lernende bestimmt: der Stil orientiert sich + am @code{modern}-Stil, aber die Alterationen, die sich durch die + Tonart ergeben, werden zusätzlich als Warnungsversetzungszeichen + gesetzt. Eine Ausnahme sind direkt wiederholte Noten. + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + \key fis \minor + #(set-accidental-style 'teaching) + \musicA + } + \context Staff = "down" { + \key fis \minor + #(set-accidental-style 'teaching) + \musicB + } + >> + } + @end lilypond + + + + @item no-reset (nicht zurücksetzen) + + @funindex no-reset + + @cindex Versetzungszeichenstil, no reset + @cindex Versetzungszeichenstil: nicht zurücksetzen + + Das ist der gleiche Stil wie @code{default}, aber die Versetzungszeichen + dauern für @qq{immer} an, nicht nur im aktuellen Takt: + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'no-reset) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'no-reset) + \musicB + } + >> + } + @end lilypond + + @item forget (vergessen) + + @funindex forget + + @cindex forget-Versetzungszeichenstil + @cindex Versetzungszeichenstil forget + @cindex Versetzungszeichenstil Vergessen + + Das ist das Gegenteil von @code{no-reset}: Versetzungszeichen + werden überhaupt nicht erinnert und folgerichtig werden alle + Versetzungszeichen entsprechend der Tonart gesetzt, unabhängig + vom Kontext der Noten. Anders als @code{dodecaphonic} werden nie + Auflösungszeichen gesetzt: + + @lilypond[quote] + musicA = { + << + \relative c' { + cis'8 fis, d'4 8 f bis4 | + cis2. 4 | + } + \\ + \relative c' { + ais'2 cis, | + fis8 b a4 cis2 | + } + >> + } + + musicB = { + \clef bass + \new Voice { + \voiceTwo \relative c' { + 4 + \change Staff = up + cis' + \change Staff = down + + \change Staff = up + dis' | + \change Staff = down + 4 gis 2 | + } + } + } + + \new PianoStaff { + << + \context Staff = "up" { + #(set-accidental-style 'forget) + \musicA + } + \context Staff = "down" { + #(set-accidental-style 'forget) + \musicB + } + >> + } + @end lilypond + @end table + + @snippets + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {dodecaphonic-style-accidentals-for-each-note-including-naturals.ly} + + + @seealso + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{Accidental}, + @rinternals{Accidental_engraver}, + @rinternals{GrandStaff} and + @rinternals{PianoStaff}, + @rinternals{Staff}, + @rinternals{AccidentalSuggestion}, + @rinternals{AccidentalPlacement}, + @rinternals{accidental-suggestion-interface}. + + + @cindex Versetzungszeichen und gleichzeitige Noten + @cindex simultane Noten und Versetzungszeichen + @cindex Akkorde: Versetzungszeichen + @cindex gleichzeitige Noten: Versetzungszeichen + @cindex Versetzungszeichen in Akkorden + + @knownissues + + Gleichzeitig erklingende Noten müssen im sequenziellen Modus eingegeben + werden. Das bedeutet, dass die Versetzungszeichen von Noten in + Akkorden so gesetzt werden, als ob die Noten nacheinander auftreten, + in der Reihenfolge, in der sie im Quelltext erscheinen. Das ist ein + Problem, wenn Versetzungzeichen in einem AKkord voneinander abhängen, + was im Standard-Stil nicht vorkommt. Das Problem kann gelöst werden, + indem man manuell@tie{}@code{!} oder@tie{}@code{?} für die problematischen + Noten schreibt. + + + @node Tonumfang + @unnumberedsubsubsec Tonumfang + @translationof Ambitus + + @cindex Ambitus + @cindex Stimmumfang + + Der Begriff @notation{ambitus} (Pl. ambitus) beschreibt den + Stimmumfang einer Stimme. Er kann auch die Töne bedeuten, die + ein Musikinstrument zu spielen in der Lage ist. Ambitus werden + in Chorpartituren gesetzt, damit die Sänger schnell wissen, ob + sie die Stimme meistern können. + + Ambitus werden zu Beginn des Stückes nahe des ersten Schlüssels + notiert. Der Stimmumfang wird durch zwei Notenköpfe dargestellt, + die die tiefste und höchste Note der Stimme repräsentieren. + Versetzungszeichen werden nur gesetzt, wenn sie nicht durch die + Tonart definiert werden. + + @lilypond[verbatim,quote] + \layout { + \context { + \Voice + \consists "Ambitus_engraver" + } + } + + \relative c'' { + aes c e2 + cis,1 + } + @end lilypond + + + @snippets + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {adding-ambitus-per-voice.ly} + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {ambitus-with-multiple-voices.ly} + + + @seealso + Glossar: + @rglos{ambitus}. + + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{Ambitus_engraver}, + @rinternals{Voice}, + @rinternals{Staff}, + @rinternals{Ambitus}, + @rinternals{AmbitusAccidental}, + @rinternals{AmbitusLine}, + @rinternals{AmbitusNoteHead}, + @rinternals{ambitus-interface}. + + + @knownissues + + Es gibt keine Kollisionskontrolle bei mehreren Ambitus in einem System. + + + @node Notenköpfe + @subsection Notenköpfe + @translationof Note heads + + Dieser Abschnitt zeigt, wie man Notenköpfe ändern kann. + + @menu + * Besondere Notenköpfe:: + * Easy-Notation-Notenköpfe:: + * Notenköpfe mit besonderen Formen:: + * Improvisation:: + @end menu + + @node Besondere Notenköpfe + @unnumberedsubsubsec Besondere Notenköpfe + @translationof Special note heads + + @cindex Notenköpfe, besondere + @cindex besondere Notenköpfe + @cindex Notenköpfe, Kreuz + @cindex Notenköpfe, Raute + @cindex Noten, parlato + @cindex Notenköpfe, Flageolett + @cindex Notenköpfe, Gitarre + @cindex Kreuznotenköpfe + @cindex Rautennotenköpfe + @cindex Parlato-Notenköpfe + @cindex Gitarrennotenköpfe + @cindex Flageolett-Notenköpfe + @cindex Stile, Notenköpfe + + @funindex cross + + Notenköpfe können verändert werden: + + @lilypond[verbatim,quote,relative=2] + c4 b a b + \override NoteHead #'style = #'cross + c4 b a b + \revert NoteHead #'style + c4 d e f + @end lilypond + + Es gibt einen definierten Befehl für die Raute, der nur innerhalb + von Akkorden benutzt werden kann: + + @lilypond[verbatim,quote,relative=2] + 2 4 + @end lilypond + + @noindent + Alle möglichen Notenkopf-Stile finden sich in + @ref{Notenkopfstile}. + + @seealso + Schnipsel: + @rlsr{Pitches}. + + Notationsreferenz: + @ref{Notenkopfstile}, + @ref{Noten mit Akkorden}. + + Referenz der Interna: + @rinternals{note-event}, + @rinternals{Note_heads_engraver}, + @rinternals{Ledger_line_engraver}, + @rinternals{NoteHead}, + @rinternals{LedgerLineSpanner}, + @rinternals{note-head-interface}, + @rinternals{ledger-line-spanner-interface}. + + + @node Easy-Notation-Notenköpfe + @unnumberedsubsubsec Easy-Notation-Notenköpfe + @translationof Easy notation note heads + + @cindex Notenköpfe, Übung + @cindex Notenköpfe zum Lernen + @cindex Übungszwecke, Notenköpfe + @cindex Noteknöpfe, einfache Notation + @cindex pädagogische Notenköpfe + @cindex Hal Leonard + @cindex Anfänger, Notenlernen + @cindex Notenköpfe für Anfänger + + @funindex \easyHeadsOn + @funindex easyHeadsOn + @funindex \easyHeadsOff + @funindex easyHeadsOff + + Die @qq{einfachen Notenköpfe} haben die Bezeichnung der Note + im Kopf gedruckt. Das wird eingesetzt, um die Notation beizubringen. + Damit die Buchstaben noch lesbar sind, müssen sie sehr groß + gesetzt werden. Wie man eine größere Schriftart einstellt, findet + sich in @ref{Die Notensystemgröße einstellen}. + + @lilypond[verbatim,quote] + #(set-global-staff-size 26) + \relative c' { + \easyHeadsOn + c2 e4 f + g1 + \easyHeadsOff + c,1 + } + @end lilypond + + @funindex \easyHeadsOn + @funindex \easyHeadsOff + + @predefined + @code{\easyHeadsOn}, + @code{\easyHeadsOff}. + @endpredefined + + @seealso + Notationsreferenz: + @ref{Die Notensystemgröße einstellen}. + + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{note-event}, + @rinternals{Note_heads_engraver}, + @rinternals{NoteHead}, + @rinternals{note-head-interface}. + + + @node Notenköpfe mit besonderen Formen + @unnumberedsubsubsec Notenköpfe mit besonderen Formen + @translationof Shape note heads + + @cindex Notenköpfe, Formen + @cindex Notation, Aiken + @cindex Notenköpfe, sacred harp + @cindex Form-Notenköpfe + @cindex Aiken-Notenköpfe + @cindex sacred harp-Notenköpfe + + @funindex \key + @funindex \aikenHeads + @funindex \sacredHarpHeads + @funindex key + @funindex aikenHeads + @funindex sacredHarpHeads + + In dieser Notation haben die Notenköpfe eine Form, die ihrer + harmonischen Funktion innherhalb der Tonleiter entspricht. Die + Notation war sehr beliebt in amerikanischen Liederbüchern des + 19. Jahrhunderts. Auf diese Weise können die Formen benutzt + werden: + + @lilypond[verbatim,quote,relative=2] + \aikenHeads + c, d e f g a b c + \sacredHarpHeads + c, d e f g a b c + @end lilypond + + Die unterschiedlichen Formen richten sich nach der Stufe in der + Skala, wobei der Grundton der Skala aus dem @code{\key}-Befehl + entnommen wird. + + @predefined + @code{\aikenHeads}, + @code{\sacredHarpHeads}. + @endpredefined + + @snippets + + @lilypondfile[verbatim,lilyquote,texidoc,doctitle] + {applying-note-head-styles-depending-on-the-step-of-the-scale.ly} + + @noindent + Alle Notenkopfstile finden sich in @ref{Notenkopfstile}. + + @seealso + Schnipsel: + @rlsr{Pitches}. + + Notationsreferenz: + @ref{Notenkopfstile}. + + Referenz der Interna: + @rinternals{note-event}, + @rinternals{Note_heads_engraver}, + @rinternals{NoteHead}, + @rinternals{note-head-interface}. + + + @node Improvisation + @unnumberedsubsubsec Improvisation + @translationof Improvisation + + @cindex Improvisation + @cindex schräge Notenköpfe + @cindex Notenköpfe, Improvisation + @cindex Strichnotenköpfe + @cindex Striche: Notenköpfe + + @funindex \improvisationOn + @funindex improvisationOn + @funindex \improvisationOff + @funindex improvisationOff + + Improvisation wird manchmal angezeigt, indem schräge Notenköpfe + gesetzt werden, wenn der Spieler eine beliebige Tonhöhe wählen kann + aber den vorgegebenen Rhythmus spielen soll. Sie können wie folgt + benutzt werden: + + @lilypond[verbatim,quote,relative=2] + \new Voice \with { + \consists "Pitch_squash_engraver" + } { + e8 e g a a16( bes) a8 g + \improvisationOn + e8 ~ + e2 ~ e8 f4 f8 ~ + f2 + \improvisationOff + a16( bes) a8 g e + } + @end lilypond + + @predefined + @code{\improvisationOn}, + @code{\improvisationOff}. + @endpredefined + + @seealso + Schnipsel: + @rlsr{Pitches}. + + Referenz der Interna: + @rinternals{Pitch_squash_engraver}, + @rinternals{Voice}, + @rinternals{RhythmicStaff}. + +