X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Documentation%2Fde%2Fnotation%2Frhythms.itely;fp=Documentation%2Fde%2Fnotation%2Frhythms.itely;h=06323b855491b03a0c577148f067e0aa6bc39d5d;hb=941dff9d2a67080e0dd8474f1e70f0c72ace6424;hp=0000000000000000000000000000000000000000;hpb=5a22d6233a39d3164e1ca043244794c268be4ad0;p=lilypond.git diff --git a/Documentation/de/notation/rhythms.itely b/Documentation/de/notation/rhythms.itely new file mode 100644 index 0000000000..06323b8554 --- /dev/null +++ b/Documentation/de/notation/rhythms.itely @@ -0,0 +1,3506 @@ +@c -*- coding: utf-8; mode: texinfo; documentlanguage: de -*- +@ignore + Translation of GIT committish: bf45bed3887f818f2d99756e6b92c77a8698be92 + + When revising a translation, copy the HEAD committish of the + version that you are working on. For details, see the Contributors' + Guide, node Updating translation committishes. +@end ignore + +@c \version "2.14.0" + +@c Translators: Till Paala + +@node Rhythmus +@section Rhythmus +@translationof Rhythms + +@lilypondfile[quote]{rhythms-headword.ly} + +Dieser Abschnitt erklärt die Eingabe von Rhythmen, Pausen, +Dauern, Bebalkung und Takten. + +@menu +* Rhythmen eingeben:: +* Pausen eingeben:: +* Rhythmen anzeigen lassen:: +* Balken:: +* Takte:: +* Besondere rhythmische Fragen:: +@end menu + + +@node Rhythmen eingeben +@subsection Rhythmen eingeben +@translationof Writing rhythms + +@menu +* Tondauern:: +* Andere rhythmische Aufteilungen:: +* Tondauern skalieren:: +* Bindebögen:: +@end menu + +@node Tondauern +@unnumberedsubsubsec Tondauern +@translationof Durations + +@cindex Dauer +@cindex Notenlänge +@cindex Notendauer, Standard +@cindex Standard Notendauer + + +@funindex \longa +@funindex \breve +@funindex \maxima +@funindex longa +@funindex breve +@funindex maxima + +Notenlängen (Dauern) werden durch +Zahlen und Punkte notiert: Dauern werden als reziproke Werte geschrieben. +Zum Beispiel wird eine Viertelnote mit @code{4} notiert (weil sie eine +1/4-Note ist), eine halbe Note mit @code{2} (weil sie eine 1/2-Note ist). +Noten, die länger als eine Ganze sind, müssen mit @code{\longa} +(für die Longa, also vier Ganze) und +@code{\breve} (für die Brevis, auch Doppelganze genannt) notiert werden. +Notendauern bis hin zu 128steln sind unterstützt. Kürzere Notenwerte können +auch notiert werden, können allerdings nur als Noten mit Balken auftreten. + +@c Two 64th notes are needed to obtain beams +@lilypond[quote,verbatim,relative=2] +\time 8/1 +c\longa c\breve c1 c2 +c4 c8 c16 c32 c64 c128 c128 +@end lilypond + +Hier die selben Notendauern ohne die Balken. + +@c not strictly "writing rhythms"; more of a "displaying" thing, +@c but it's ok here. -gp +@lilypond[quote,verbatim,relative=2] +\time 8/1 +\autoBeamOff +c\longa c\breve c1 c2 +c4 c8 c16 c32 c64 c128 c128 +@end lilypond + +Eine Note mit der vierfachen Dauer einer Brevis kann mit dem +Befehl @code{\maxima} eingegeben werden, aber ihre Darstellung +ist nur für die Alte Musiknotation unterstützt. Zu Einzelheiten +siehe @ref{Notation von alter Musik}. + +@cindex Dauer, Standard +@cindex Standardnotendauer +@cindex Notendauer, Standard + +Wenn die Dauer hinter einer Notenbezeichnung nicht angegeben ist, +wird die Dauer der vorhergehenden Note eingesetzt. Der Standardwert +für die erste Note ist eine Viertel. + +@lilypond[quote,verbatim,relative=2] +a a a2 a a4 a a1 a +@end lilypond + +@funindex . + +@cindex Punktierung +@cindex Noten, punktiert +@cindex Doppelpunktierung +@cindex Noten, doppelpunktiert + +Um punktierte Notendauern zu erhalten, muss einfach nur ein Punkt +(@code{.}) hinter die Zahl der Dauer gesetzt werden. Zwei Punkte +ergeben eine doppelte Punktierung, usw. + +@lilypond[quote,verbatim,relative=2] +a4 b c4. b8 a4. b4.. c8. +@end lilypond + +Manche Notenlängen können nicht mit binären Dauern und Punkten +dargestellt werden, sie können nur erreicht werden, indem man +Noten überbindet. Für Einzelheiten siehe @ref{Bindebögen}. + +Wie den Silben von Gesangstext eigene Dauern zugewiesen werden +können und wie man sie an den Noten ausrichtet ist erklärt in +@ref{Notation von Gesang}. + +Optional können Noten streng proportional nach ihrer exakten +Dauer gesetzt werden. Zu Einzelheiten hierzu und weiteren +Einstellungen für proportionale Notation siehe +@ref{Proportionale Notation}. + +@funindex \dotsUp +@funindex \dotsDown +@funindex \dotsNeutral +@funindex dotsUp +@funindex dotsDown +@funindex dotsNeutral + +Punkte werden normalerweise nach oben verschoben, damit sie die Notenlinien +nicht berühren. Punkte können manuelle über oder unter dem +Notensystem gesetzt werden, zu Einzelheiten +siehe @ref{Richtung und Platzierung}. + +@predefined +@code{\autoBeamOn}, +@code{\autoBeamOff}, +@code{\dotsUp}, +@code{\dotsDown}, +@code{\dotsNeutral}. +@endpredefined + +@snippets + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{changing-the-number-of-augmentation-dots-per-note.ly} + +@seealso +Glossar: +@rglos{breve}, +@rglos{longa}, +@rglos{maxima}, +@rglos{note value}, +@rglos{Duration names notes and rests}. + +Notationsreferenz: +@ref{Automatische Balken}, +@ref{Bindebögen}, +@ref{Hälse}, +@ref{Rhythmen eingeben}, +@ref{Pausen eingeben}, +@ref{Notation von Gesang}, +@ref{Notation von alter Musik}, +@ref{Proportionale Notation}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{Dots}, +@rinternals{DotColumn}. + + +@knownissues + +@c Deliberately duplicated in Durations and Rests. -gp +Es gibt keine grundlegende Grenze für die Dauer von Pausen +(sowohl kürzer als auch länger), aber die Anzahl an Symbolen +ist begrenzt: Einzelne Pausen können von 128stel bis zur +Maxima (8 Ganze) gesetzt werden. + + +@node Andere rhythmische Aufteilungen +@unnumberedsubsubsec Andere rhythmische Aufteilungen +@translationof Tuplets + +@cindex N-tolen +@cindex Triolen +@cindex Rhythmische Aufteilungen + +@funindex times +@funindex \times + +Triolen und andere rhythmische Aufteilungen werden aus einem musikalischen +Ausdruck erstellt, indem dessen Tondauern mit einem Bruch multipliziert werden. + +@example +\times @var{Bruch} @var{musikalischer Ausdruck} +@end example + +@noindent +Die Dauer eines @var{musikalischen Ausdrucks} wird mit dem Bruch multipliziert. +Der Nenner des Bruchs wird über (oder unter) den Noten ausgegeben, +optional mit einer eckigen Klammer, die die Noten einfasst. +Die üblichste Aufteilung ist die +Triole, in welcher drei Noten die Länge von zwei haben, der Wert jeder +einzelnen Note ist also 2/3 der notierten Länge. + +@lilypond[quote,verbatim,relative=2] +a2 \times 2/3 { b4 b b } +c4 c \times 2/3 { b4 a g } +@end lilypond + +@cindex Triolenklammer, Platzierung + +@funindex \tupletUp +@funindex \tupletDown +@funindex \tupletNeutral +@funindex tupletUp +@funindex tupletDown +@funindex tupletNeutral + +Triolenklammern können manuell über oder unter dem Notensystem +ausgegeben werden, siehe @ref{Richtung und Platzierung}. + + +N-tolen können ineinander geschachtelt werden: + +@lilypond[quote,verbatim,relative=2] +\autoBeamOff +c4 \times 4/5 { f8 e f \times 2/3 { e[ f g] } } f4 +@end lilypond + +Wenn man die Eigenschaften von N-tolen verändern will, die zum +selben musikalischen Zeitpunkt beginnen, muss @code{\tweak} +eingesetzt werden. + +Um die Dauern von Noten zu ändern, ohne die N-tolen-Klammern +zu setzen, siehe @ref{Tondauern skalieren}. + +@predefined +@code{\tupletUp}, +@code{\tupletDown}, +@code{\tupletNeutral}. +@endpredefined + +@snippets + +@cindex N-tole, Formatierung +@cindex Triole, Formatierung +@cindex Formatierung von Triolen + +@funindex tupletNumberFormatFunction +@funindex tupletSpannerDuration + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{entering-several-tuplets-using-only-one--times-command.ly} + +@cindex Triolennummer, Änderung + +@funindex TupletNumber + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{changing-the-tuplet-number.ly} + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{non-default-tuplet-numbers.ly} + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{controlling-tuplet-bracket-visibility.ly} + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{permitting-line-breaks-within-beamed-tuplets.ly} + +@seealso +Glossar: +@rglos{triplet}, +@rglos{tuplet}, +@rglos{polymetric}. + +Handbuch zum Lernen: +@rlearning{Optimierungsmethoden}. + +Notationrreferenz: +@ref{Verwaltung der Zeiteinheiten}, +@ref{Tondauern skalieren}, +@ref{Der tweak-Befehl}, +@ref{Polymetrische Notation}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{TupletBracket}, +@rinternals{TupletNumber}, +@rinternals{TimeScaledMusic}. + +@cindex Verzierung innerhalb von rhythmischer Kombination +@cindex Stichnoten innerhalb von rhythmischer Kombination +@cindex Verzierung innerhalb von Triole + +@knownissues +Verzierungen können innerhalb von Triolenklammern gesetzt werden, +@emph{außer} wenn ein System mit einer Verzierung beginnt, die von +einer N-tole gefolgt wird. In diesem besonderen Fall müssen die +Verzierungen vor dem @code{\times}-Befehl gesetzt werden, damit sich +keine Fehler ergeben. + +@cindex Tempobezeichnungen innerhalb von N-tolen-Klammern + +Wenn man eine N-tole zu Beginn eines Stückes notiert, das eine +Tempobezeichnung mit @code{\tempo} enthält, müssen die Noten +in einer explizit begonnenen Stimme notiert werden. Siehe +auch @rlearning{Voice enthält Noten}. + + +@node Tondauern skalieren +@unnumberedsubsubsec Tondauern skalieren +@translationof Scaling durations + +@cindex Dauern skalieren +@cindex Skalieren von Dauern + +Die Dauer von einzelnen Noten, Pausen oder Akkorden kann mit einem Bruch multipliziert werden, +indem hinter die Notendauer @qq{*@var{N/M}} (oder @qq{*@var{N}} wenn @var{M} 1 ist) +geschrieben wird. Die Erscheinung der Noten oder Pausen wird +dadurch nicht beeinflusst, die neue Dauer wird aber dazu +benutzt, ihre Position im Takt zu errechnen und die neue +Dauer in der MIDI-Ausgabe einzusetzen. Die Faktoren, mit +denen multipliziert wird, können auch kombiniert werden, etwa +@qq{*L*M*/N}. + +Im nächsten Beispiel nehmen die drei ersten Noten genau zwei Schläge ein, +aber es wird keine Triolenklammer über ihnen ausgegeben. + +@lilypond[quote,relative=2,verbatim] +\time 2/4 +% Alter durations to triplets +a4*2/3 gis4*2/3 a4*2/3 +% Normal durations +a4 a4 +% Double the duration of chord +4*2 +% Duration of quarter, appears like sixteenth +b16*4 c4 +@end lilypond + +Die Dauer von unsichtbaren Noten kann auch mit einem Faktor +beeinflusst werden. Das ist sinnvoll, wenn man viele Takte +überspringen muss, etwa @code{s1*23}. + +@cindex Musik komprimieren +@cindex Komprimieren von Noten +@cindex Noten komprimieren +@cindex Noten ausdehnen +@cindex Ausdehnen von Noten +@cindex Dauern skalieren + +@funindex scaleDurations +@funindex \scaleDurations + +Längere Notenabschnitte können auf die gleiche Art durch Multiplikation +mit einem Bruch komprimiert werden, als ob jede Note, jeder +Akkord oder jede Pause mit dem Bruch multipliziert würde. +Damit bleibt das Aussehen der Musik unverändert, aber die +interne Dauer der Noten wird mit dem Bruch multipliziert. +Die Leerzeichen um den Punkt im Beispiel sind notwendig. +Hier ein Beispiel, das zeigt, wie Noten komprimiert und +ausgedehnt werden kann: + +@lilypond[quote,relative=2,verbatim] +\time 2/4 +% Normal durations +4 c8 a +% Scale music by *2/3 +\scaleDurations #'(2 . 3) { + 4. c8 a f +} +% Scale music by *2 +\scaleDurations #'(2 . 1) { + 4 c8 b +} +@end lilypond + +Eine Anwendung für diesen Befehl ist polymetrische Notation, +siehe @ref{Polymetrische Notation}. + +@seealso +Notationsreferenz: +@ref{Andere rhythmische Aufteilungen}, +@ref{Unsichtbare Pausen}, +@ref{Polymetrische Notation}. + +Schnipsel: +@rlsr{Rhythms}. + + +@node Bindebögen +@unnumberedsubsubsec Bindebögen +@translationof Ties + +@cindex Bindebogen +@cindex Überbindung + +@funindex ~ + +Ein Bindebogen verbindet zwei benachbarte Noten der selben +Tonhöhe. Als Resultat wird die Dauer der Notenlänge verlängert. + +@warning{Bindebögen (engl. tie) dürfen nicht mit Legatobögen +(engl. slur) verwechselt werden, durch +die die Vortragsart bezeichnet wird, noch mit Phrasierungsbögen +(engl. phrasing slur), +die musikalische Phrasen anzeigen. Ein Bindebogen ist nur eine +Art, die Tondauer zu verlängern, ähnlich etwa wie die +Punktierung.} + +Ein Bindebogen wird mit der +Tilde @code{~} (AltGr++) notiert. + +@lilypond[quote,verbatim,relative=2] +a2 ~ a +@end lilypond + +Bindebögen werden eingesetzt, wenn die Note entweder über eine +Taktlinie hinüberreicht, oder wenn die entsprechende Dauer der +Note nicht mit Punktierung erreicht werden kann. Bindebögen +sollten auch benutzt werden, wenn Notenwerte über die +inneren Unterteilungen von Takten hinüberreichen: + +@lilypond[quote] +\relative c' { + r8 c8 ~ c2 r4 | + r8^"not" c2 ~ c8 r4 +} +@end lilypond + +Wenn viele Noten über Taktlinien gebunden werden müssen, kann +es einfacher sein, automatische Notenaufteilung einzustellen, +wie beschrieben in @ref{Automatische Aufteilung von Noten}. +Mit diesem Mechanismus werden lange Noten +automatisch aufgeteilt, wenn sie über Taktgrenzen reichen. + +@cindex Bindebögen und Akkorde +@cindex Überbindungen und Akkorde +@cindex Akkorde und Überbindungen + +Wenn ein Bindebogen an einen Akkord gehängt wird, werden alle Noten +dieses Akkordes übergebunden. Wenn kein Notenkopf passt, wird auch +kein Bogen erzeugt. Noten in Akkorden können auch einzeln übergebunden +werden, indem sie innerhalb des Akkordes hinter die entsprechende Note +geschrieben werden. + +@lilypond[quote,verbatim,relative=1] + ~ + +@end lilypond + +@cindex Bindebögen wiederholen +@cindex Wiederholung und Bindebögen +@cindex Überbindung und Wiederholungen +@cindex Volta-Klammern und Wiederholungen +@cindex Volta und Überbindung + +@funindex \repeatTie +@funindex repeatTie + +Wenn die zweite Variante einer Wiederholung mit einer übergebundenen +Note anfängt, muss der Bindebogen wie folgt notiert werden: + +@lilypond[quote,relative=2,verbatim] +\repeat volta 2 { c g 2 ~ } +\alternative { + % First alternative: following note is tied normally + { 2. r4 } + % Second alternative: following note has a repeated tie + { 2\repeatTie d4 c } } +@end lilypond + +@cindex Laissez vibrer +@cindex Ausklingen lassen, Bögen +@cindex Bögen, laissez vibrer +@cindex Ausklingen lassen + +@funindex laissezVibrer +@funindex \laissezVibrer + +So genannte @notation{laissez vibrer}-Bögen werden verwendet um anzuzeigen, dass +man die Musik ausklingen lassen soll. Sie werden in der Klavier-, Harfen-, +anderer Saiteninstrument- und Schlagzeugnotation verwendet. Sie können folgendermaßen notiert werden: + +@lilypond[quote,verbatim,relative=1] +1\laissezVibrer +@end lilypond + +@cindex ties, placement + +@funindex \tieUp +@funindex \tieDown +@funindex \tieNeutral +@funindex tieUp +@funindex tieDown +@funindex tieNeutral + +Bindebögen können manuell über oder unter dem Notensystem +gesetzt werden. Zu Einzelheiten siehe @ref{Richtung und Platzierung}. + +@cindex Bindebögen, Aussehen +@cindex Bindebögen, gestrichelt +@cindex Bindebögen, gepunktet +@cindex Bindebögen, durchgehend + +@funindex \tieDotted +@funindex \tieDashed +@funindex \tieSolid +@funindex tieDotted +@funindex tieDashed +@funindex tieSolid + +Bindebögen können durchgehend, gestrichelt, gepunktet oder in einer Kombination +von Strichen und durchgehender Linie definiert werden. + +@lilypond[quote, verbatim, relative=1] +\tieDotted +c2 ~ c +\tieDashed +c2 ~ c +\tieHalfDashed +c2 ~ c +\tieHalfSolid +c2 ~ c +\tieSolid +c2 ~ c +@end lilypond + +Eigene Strichelungsmuster können definiert werden: + +@lilypond[quote, verbatim, relative=1] +\tieDashPattern #0.3 #0.75 +c2 ~ c +\tieDashPattern #0.7 #1.5 +c2 ~ c +\tieSolid +c2 ~ c +@end lilypond + +Die Definition von Muster für die Strichelung der Bindebögen hat +die gleiche Struktur wie die Definition für Legatobögen. Zu +weiterer Information zu komplizierten Strichelungsmustern, siehe +die Schnipsel im Abschnitt @ref{Legatobögen}. + +@predefined +@code{\tieUp}, +@code{\tieDown}, +@code{\tieNeutral}, +@code{\tieDotted}, +@code{\tieDashed}, +@code{\tieDashPattern}, +@code{\tieHalfDashed}, +@code{\tieHalfSolid}, +@code{\tieSolid}. +@endpredefined + +@snippets + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{using-ties-with-arpeggios.ly} + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{engraving-ties-manually.ly} + +@seealso +Glossar: +@rglos{tie}, +@rglos{laissez vibrer}. + +Notationsreferenz: +@ref{Legatobögen}, +@ref{Automatische Aufteilung von Noten}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{LaissezVibrerTie}, +@rinternals{LaissezVibrerTieColumn}, +@rinternals{TieColumn}, +@rinternals{Tie}. + +@knownissues +Der Wechsel zwischen Systemen bei aktiver Überbindung produziert keinen +gekrümmten Bogen. + +Änderung von Schlüssel oder Oktavierung zwischen übergebundenen Noten +ist nicht richtig definiert. In diesen Fällen kann es besser sein, einen +Legatobogen zu verwenden. + + +@node Pausen eingeben +@subsection Pausen eingeben +@translationof Writing rests + +Pausen werden als Teil der musikalischen Ausdrücke zusammen mit +den Noten notiert. + +@menu +* Pausen:: +* Unsichtbare Pausen:: +* Ganztaktpausen:: +@end menu + +@node Pausen +@unnumberedsubsubsec Pausen +@translationof Rests + +@cindex Pausen +@cindex Pausendauern +@cindex Maxima-Pause +@cindex Longa-Pause +@cindex Brevis-Pause + +@funindex \rest +@funindex r +@funindex \maxima +@funindex \longa +@funindex \breve +@funindex rest +@funindex maxima +@funindex longa +@funindex breve + +Pausen werden wie Noten eingegeben, ihre Bezeichnung ist @code{r}. +Dauern, die länger als eine Ganze sind, haben die +vordefinierten Befehle: + +@c \time 16/1 is used to avoid spurious bar lines +@c and long tracts of empty measures +@lilypond[quote,verbatim,relative=2] +\new Staff { + % These two lines are just to prettify this example + \time 16/1 + \override Staff.TimeSignature #'stencil = ##f + % Print a maxima rest, equal to four breves + r\maxima + % Print a longa rest, equal to two breves + r\longa + % Print a breve rest + r\breve + r1 r2 r4 r8 r16 r32 r64 r128 +} +@end lilypond + +@cindex Pausen, mehrtaktig +@cindex Pausen, ganztaktig +@cindex Ganztaktpausen +@cindex Mehrtaktpausen + +Pausen, die ganze Takte ausfüllen und in der Taktmitte zentriert +werden sollen, müssen als mehrtaktige Pausen eingegeben werden. +Sie können sowohl für einen einzigen Takt als auch für mehrere +Takte verwendet werden, Näheres im Abschnitt +@ref{Ganztaktpausen}. + +@cindex Pausen, vertikale Position festlegen + +Um die vertikale Position einer Pause explizit festzulegen, +kann eine Note eingegeben werden, gefolgt vom Befehl @code{\rest}. +Die Pause wird dann an die Stelle gesetzt, wo sich sonst die +Note befinden würde. Damit wird die manuelle Formatierung von mehrstimmiger Musik +sehr viel einfacher, da die Formatierungsfunktion zur automatischen +Auflösung von Zusammenstößen diese Pausen nicht mit einbezieht. + +@lilypond[quote,verbatim,relative=2] +a4\rest d4\rest +@end lilypond + +@snippets + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{rest-styles.ly} + +@seealso +Glossar: +@rglos{breve}, +@rglos{longa}, +@rglos{maxima}. + +Notationsreferenz: +@ref{Ganztaktpausen}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{Rest}. + + +@knownissues + +@c Deliberately duplicated in Durations and Rests. -gp +Es gibt keine grundlegende Grenze für die Dauer von Pausen (sowohl +kürzer als auch länger), aber die Anzahl von Symbolen ist +begrenzt: Es gibt Zeichen für Pausen von einer 128 bis zu einer +Maxima (8 Ganze). + + +@node Unsichtbare Pausen +@unnumberedsubsubsec Unsichtbare Pausen +@translationof Invisible rests + +@cindex Skip +@cindex Überspringen von Zeichen +@cindex Unsichtbare Pausen +@cindex Pausen, unsichtbar +@cindex Platzhalternoten + +@funindex \skip +@funindex skip +@funindex s + +Eine unsichtbare Pause (auch als @qq{skip} oder Überspringung bezeichnet) +kann wie eine Note eingegeben werden, die Notationsbezeichnung ist @code{s}. + +@lilypond[quote,verbatim,relative=2] +a4 a4 s4 a4 \skip 1 a4 +@end lilypond + +@cindex Gesangstext, Note überspringen + +Die @code{s}-Syntax steht nur im Noten- oder Akkordmodus zur Verfügung. In +anderen Situationen, z. B. innerhalb eines Liedtextes, muss +der Befehl @code{\skip} benutzt werden. @code{\skip} benötigt eine +explizite Dauerangabe. + +@lilypond[quote,verbatim,relative=2] +<< + { + a2 \skip2 a2 a2 + } + \new Lyrics { + \lyricmode { + foo2 \skip 1 bla2 + } + } +>> +@end lilypond + +Weil @code{\skip} ein Befehl ist, wirkt er sich nicht auf die Dauer +der folgenden Noten aus, anders als@tie{}@code{s}. + +@lilypond[quote,verbatim,relative=2] +<< + { + \repeat unfold 8 { a4 } + } + { + a4 \skip 2 a | + s2 a + } +>> +@end lilypond + +Die Platzhalterpause mit @code{s} erstellt @code{Staff}- und +@code{Voice}-Kontext, wenn es erforderlich ist, genauso wie Noten und Pausen. + +@lilypond[quote,verbatim,relative=2] +s1 s s +@end lilypond + +Der Überspringungsbefehl (@code{\skip}) ist einfach ein leerer Platzhalter. +Durch ihn wird überhaupt nichts gesetzt, auch keine transparenten Objekte. + +@lilypond[quote,verbatim,relative=2] +% This is valid input, but does nothing +\skip 1 \skip1 \skip 1 +@end lilypond + +@seealso +Handbuch zum lernen: +@rlearning{Sichtbarkeit und Farbe von Objekten}. + +Notationsreferenz: +@ref{Unsichtbare Noten}, +@ref{Sichtbarkeit von Objekten}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{SkipMusic} + + + +@node Ganztaktpausen +@unnumberedsubsubsec Ganztaktpausen +@translationof Full measure rests + +@cindex Ganztaktpausen +@cindex Mehrtaktpausen +@cindex Pausen, Ganztakt- +@cindex Pausen, Mehrtakt- + +@funindex R + +Pausen für einen oder mehrere ganze Takte werden wie +Noten eingegeben, wobei die Bezeichnung ein Großbuchstabe +@code{R} ist: + +@lilypond[quote,verbatim,relative=2] +% Rest measures contracted to single measure +\compressFullBarRests +R1*4 +R1*24 +R1*4 +b2^"Tutti" b4 a4 +@end lilypond + +Die Dauer von Ganztaktpausen wird genauso angegeben wie die +Dauer von Noten. Die Dauer einer Ganztaktpause muss immer +eine ganze Anzahl an Taktlängen sein, weshalb Punktierungen +und Brüche recht häufig eingesetzt werden müssen. + +@lilypond[quote,relative=2,verbatim] +\compressFullBarRests +\time 2/4 +R1 | R2 | +\time 3/4 +R2. | R2.*2 | +\time 13/8 +R1*13/8 | R1*13/8*12 | +\time 10/8 +R4*5*4 | +@end lilypond + +Eine Ganztaktpause wird abhängig von der Taktart entweder als +Ganze oder Brevis-Pause gesetzt, zentriert im Takt. + +@lilypond[quote,verbatim,relative=2] +\time 4/4 +R1 | +\time 6/4 +R1*3/2 | +\time 8/4 +R1*2 | +@end lilypond + +@cindex Mehrtaktpausen, ausschreiben +@cindex Pausen, mehrere Takte ausschreiben +@cindex Pausen, mehrere Takte komprimieren +@cindex Mehrtaktpausen, komprimieren + +@funindex \expandFullBarRests +@funindex \compressFullBarRests +@funindex expandFullBarRests +@funindex compressFullBarRests + +In den Standardeinstellungen werden mehrtaktige Pausen +ausgeschrieben gesetzt, sodass sie die entsprechende Anzahl von +Takten einnehmen. Alternativ kann die mehrtaktige Pause +aber auch nur in einem Takt angezeigt werden, der ein +Mehrtaktpausensymbol beinhaltet, wobei die Anzahl der Takte +der Pausendauer über dem Pausenzeichen ausgegeben wird: + +@lilypond[quote,relative=2,verbatim] +% Default behavior +\time 3/4 r2. | R2.*2 | +\time 2/4 R2 | +\time 4/4 +% Rest measures contracted to single measure +\compressFullBarRests +r1 | R1*17 | R1*4 | +% Rest measures expanded +\expandFullBarRests +\time 3/4 +R2.*2 | +@end lilypond + + +@cindex Text über Mehrtaktpausen +@cindex Mehrtaktpausen, Text hinzufügen +@cindex Beschriftung über Mehrtaktpausen +@cindex Mehrtaktpausen, Beschriftung +@cindex Fermate über Mehrtaktpausen +@cindex Mehrtaktpause mit Fermate + +@funindex \fermataMarkup +@funindex fermataMarkup +@funindex MultiMeasureRestText + +Textbeschriftung kann Mehrtaktpausen mit @code{\markup} +hinzugefügt werden. Ein +vordefinierte Befehl @code{\fermataMarkup} fügt eine +Fermate ein. + +@lilypond[quote,verbatim,relative=2] +\compressFullBarRests +\time 3/4 +R2.*10^\markup { \italic "ad lib." } +R2.^\fermataMarkup +@end lilypond + +@warning{ +Beschriftungen, die an Mehrtaktpausen gehängt werden, sind +Objekte vom Typ @code{MultiMeasureRestText}, nicht vom Typ +@code{TextScript}. Änderungen etwa mit @code{\override} +müssen auf das richtige Objekt gerichtet werden, damit sie +nicht ignoriert werden. Siehe auch das folgende Beispiel. +} + +@lilypond[quote,verbatim,relative=2] +% This fails, as the wrong object name is specified +\override TextScript #'padding = #5 +R1^"wrong" +% This is the correct object name to be specified +\override MultiMeasureRestText #'padding = #5 +R1^"right" +@end lilypond + +Wenn eine Mehrtaktpause direkt auf einen Auftakt mit @code{\partial} +folgt, werden möglicherweise daraus resultierende +Taktprüfungswarnungen nicht angezeigt. + +@funindex \textLengthOn +@funindex textLengthOn +@funindex \textLengthOff +@funindex textLengthOff +@funindex \fermataMarkup +@funindex fermataMarkup +@funindex \compressFullBarRests +@funindex compressFullBarRests +@funindex \expandFullBarRests +@funindex expandFullBarRests + +@predefined +@code{\textLengthOn}, +@code{\textLengthOff}, +@code{\fermataMarkup}, +@code{\compressFullBarRests}, +@code{\expandFullBarRests}. +@endpredefined + +@snippets + +@cindex Kirchenpausen +@cindex Pausen, Kirchenstil +@cindex Balkenpausen, mehrtaktig + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{changing-form-of-multi-measure-rests.ly} + +@cindex Mehrtaktpausen, Positionierung +@cindex Position von Mehrtaktpausen + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{positioning-multi-measure-rests.ly} + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{multi-measure-rest-markup.ly} + +@seealso +Glossar: +@rglos{multi-measure rest}. + +Notationsreferenz: +@ref{Tondauern}, +@ref{Text}, +@ref{Text formatieren}, +@ref{Textarten}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{MultiMeasureRest}, +@rinternals{MultiMeasureRestNumber}, +@rinternals{MultiMeasureRestText}. + +@cindex Fingersatz und Mehrtaktpausen +@cindex Mehrtaktpausen und Fingersatz +@cindex Ganztaktpausen und Fingersatz + +@knownissues +Wenn man versucht, mit Fingersatz (etwa @code{R1*10-4} Zahlen +über Ganztaktpausen zu setzen, kann die Zahl des Fingersatzes +(4) mit der Taktanzahl (10) zusammenstoßen. + +@cindex Zusammenfalten von Pausen +@cindex Pausen, Zusammenfalten + +Es gibt keine Möglichkeit, normale Pausen automatisch zu +Ganztaktpausen zu reduzieren. + +@cindex Pausen, Zusammenstöße + +Ganztaktpausen werden bei der Vermeidung von Zusammenstößen nicht +berücksichtigt. + + +@node Rhythmen anzeigen lassen +@subsection Rhythmen anzeigen lassen +@translationof Displaying rhythms + +@menu +* Taktangabe:: +* Metronomangabe:: +* Auftakte:: +* Musik ohne Metrum:: +* Polymetrische Notation:: +* Automatische Aufteilung von Noten:: +* Melodierhythmus anzeigen:: +@end menu + +@node Taktangabe +@unnumberedsubsubsec Taktangabe +@translationof Time signature + +@cindex Taktangabe +@cindex Metrum + +@funindex time +@funindex \time + +Taktangaben werden wie folgt erstellt. + +@lilypond[quote,verbatim,relative=2] +\time 2/4 c'2 +\time 3/4 c'2. +@end lilypond + +@cindex Taktangabe, Sichtbarkeit + +Taktangaben werden zu Beginn eines Stückes gesetzt und immer dann, +wenn sich die Taktart ändert. Wenn eine Änderung am Ende einer +Zeile geschieht, wird eine warnende Taktangabe am Ende der Zeile +ausgegeben. Dieses Verhalten kann verändert werden, siehe +@ref{Sichtbarkeit von Objekten}. + +@lilypond[quote,verbatim,relative=2] +\time 2/4 +c2 c +\break +c c +\break +\time 4/4 +c c c c +@end lilypond + +@funindex \numericTimeSignature +@funindex \defaultTimeSignature +@funindex numericTimeSignature +@funindex defaultTimeSignature + +@cindex Stil von Taktangaben +@cindex Taktangaben-Stile + +Das Symbol für die Taktarten 2/2 und 4/4 kann in ein Zahlensymbol +umgewandelt werden: + +@lilypond[quote,verbatim,relative=2] +% Default style +\time 4/4 c1 +\time 2/2 c1 +% Change to numeric style +\numericTimeSignature +\time 4/4 c1 +\time 2/2 c1 +% Revert to default style +\defaultTimeSignature +\time 4/4 c1 +\time 2/2 c1 +@end lilypond + +Symbole für Modus und Proprietas der mensuralen Notation +werden behandelt unter @ref{Mensurale Taktartenbezeichnungen}. + +@cindex Taktart, Standardeinstellung +@cindex Standardtakteinstellungen +@cindex Bebalkung, Taktartstandard +@cindex Balken, Taktartstandard + +@funindex \overrideTimeSignatureSettings +@funindex overrideTimeSignatureSettings + +Zusätzlich zu der gedruckten Taktart werden mit der Definition des +Befehls @code{\time} auch die Standardwerte fürt die Eigenschaften +@code{baseMoment}, @code{beatStructure} und @code{beamExtensions} +gesetzt. Die vordefinierten Standardwerte für diese Eigenschaften +finden sich in @file{scm/time-signature-settings.scm}. Die existierenden +Standardwerte können verändert oder neue Standardwerte hinzugefügt +werden. + +@lilypond[quote,verbatim] +\score { + \new Staff { + \relative c' { + \overrideTimeSignatureSettings + #'(4 . 4) % timeSignatureFraction + #'(1 . 4) % baseMomentFraction + #'(3 1) % beatStructure + #'() % beamExceptions + \time 4/4 + \repeat unfold 8 { c8 } | + } + } +} +@end lilypond + +@code{\overrideTimeSignatureSettings} braucht fünf Argumente: + +@enumerate + +@item +@code{@var{timeSignatureFraction}} (Taktart-Bruch), ein Scheme-Paar, +das den Takt beschreibt. + +@item +@code{@var{baseMomentFraction}} (Grundmoment-Bruch), ein Scheme-Paar, das +den Zähler und Nenner der Grundschlageinheit der Taktart enhält. + +@item +@code{@var{beatStructure}} (Taktzeit-Struktur), eine Scheme-Liste, die +die Struktur der Taktschläge anzeigt, in Einheiten des Grundmoments. + +@item +@code{@var{beamExceptions}} (Balken-Ausnahmen), eine Aliste, die alle +Bebalkungsregeln für die Taktart enthält, außer dem Balken, der zum Taktende +endet, wie beschrieben in @ref{Einstellung von automatischen Balken}. +@end enumerate + +Der Kontext, der @code{\overrideTimeSignatureSettings} enthält, muss +begonnen sein, bevor @code{\overrideTimeSignatureSettings} aufgerufen +wird. Das heißt, dass er entweder explizit begonnen wird oder sich +Noten in dem Kontext befinen müssen, bevor +@code{\overrideTimeSignatureSettings} aufgerufen wird: + +@lilypond[quote,verbatim] +\score { + \relative c' { + % This call will fail because the context isn't yet instantiated + \overrideTimeSignatureSettings + #'(4 . 4) % timeSignatureFraction + #'(1 . 4) % baseMomentFraction + #'(3 1) % beatStructure + #'() % beamExceptions + \time 4/4 + c8^\markup {"Beamed (2 2)"} + \repeat unfold 7 { c8 } | + % This call will succeed + \overrideTimeSignatureSettings + #'(4 . 4) % timeSignatureFraction + #'(1 . 4) % baseMomentFraction + #'(3 1) % beatStructure + #'() % beamExceptions + \time 4/4 + c8^\markup {"Beamed (3 1)"} + \repeat unfold 7 { c8 } | + } +} +@end lilypond + + + + + +@cindex Taktart, Standardeigenschaften wiederherstellen +@cindex Wiederherstellen von Taktart-Standardeigenschaften +@cindex Zurücksetzen von Taktart-Standardeigenschaften + +@funindex \revertTimeSignatureSettings +@funindex revertTimeSignatureSettings + +Veränderte Werte der Taktart-Eigenschaften können wieder auf den +Standard zurückgesetzt werden: + +@lilypond[quote,verbatim] +\score{ + \relative c' { + \repeat unfold 8 { c8 } | + \overrideTimeSignatureSettings + #'(4 . 4) % timeSignatureFraction + #'(1 . 4) % baseMomentFraction + #'(3 1) % beatStructure + #'() % beamExceptions + \time 4/4 + \repeat unfold 8 { c8 } | + \revertTimeSignatureSettings #'(4 . 4) + \time 4/4 + \repeat unfold 8 { c8 } | + } +} +@end lilypond + +Unterschiedliche Werte der Standard-Taktarteigenschaften für unterschiedliche +Notensysteme können eingerichtet werden, indem man den +@code{Timing_translator} und den @code{Default_bar_line_engraver} aus dem +@code{Score}-Kontext in den @code{Staff}-Kontext verschiebt. + +@lilypond[quote, verbatim] +\score { + \new StaffGroup << + \new Staff { + \overrideTimeSignatureSettings + #'(4 . 4) % timeSignatureFraction + #'(1 . 4) % baseMomentFraction + #'(3 1) % beatStructure + #'() % beamExceptions + \time 4/4 + \repeat unfold 8 {c''8} + } + \new Staff { + \overrideTimeSignatureSettings + #'(4 . 4) % timeSignatureFraction + #'(1 . 4) % baseMomentFraction + #'(1 3) % beatStructure + #'() % beamExceptions + \time 4/4 + \repeat unfold 8 {c''8} + } + >> + \layout { + \context { + \Score + \remove "Timing_translator" + \remove "Default_bar_line_engraver" + } + \context { + \Staff + \consists "Timing_translator" + \consists "Default_bar_line_engraver" + } + } +} +@end lilypond + +@predefined +@code{\numericTimeSignature}, +@code{\defaultTimeSignature}. +@endpredefined + +@snippets + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{changing-the-time-signature-without-affecting-the-beaming.ly} + +@cindex compound time signatures +@cindex time signature, compound + +@lilypondfile[verbatim,lilyquote,texidoc,doctitle] +{compound-time-signatures.ly} + +@lilypondfile[verbatim,lilyquote,texidoc,doctitle] +{time-signature-printing-only-the-numerator-as-a-number-instead-of-the-fraction.ly} + + +@seealso +Glossar: +@rglos{time signature} + +Notationsreferenz: +@ref{Mensurale Taktartenbezeichnungen}, +@ref{Verwaltung der Zeiteinheiten}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{TimeSignature}, +@rinternals{Timing_translator}. + + +@node Metronomangabe +@unnumberedsubsubsec Metronomangabe +@translationof Metronome marks + +@cindex Tempo +@cindex Metronombezeichnung +@cindex Tempobezeichnung +@cindex Aufführungsanweisung: Tempo + +@funindex tempo +@funindex \tempo + +Eine Metronomanweisung wird wie folgt erstellt: + +@lilypond[verbatim,quote,relative=1] +\tempo 4 = 120 +c2 d +e4. d8 c2 +@end lilypond + +Metronombezeichnungen können auch für einen Zahlenbereich notiert werden: + +@lilypond[verbatim,quote,relative=1] +\tempo 4 = 40 ~ 46 +c4. e8 a4 g +b,2 d4 r +@end lilypond + +Anstelle dessen kann auch Text als Argument angegeben werden: + +@lilypond[verbatim,quote,relative=2] +\tempo "Allegretto" +c4 e d c +b4. a16 b c4 r4 +@end lilypond + +Wenn eine Metronombezeichnung und Text kombiniert wird, wird +die Metronombezeichnung automatisch in Klammern gesetzt: + +@lilypond[verbatim,quote,relative=2] +\tempo "Allegro" 4 = 160 +g4 c d e +d4 b g2 +@end lilypond + +Der Text kann ein beliebiges Textbeschriftungsobjekt sein: + +@lilypond[verbatim,quote,relative=2] +\tempo \markup { \italic Faster } 4 = 132 +a8-. r8 b-. r gis-. r a-. r +@end lilypond + +Eine Metronombezeichnung in Klammern ohne Text kann erstellt +werden, indem eine leere Zeichenkette hinzugefügt wird: + +@lilypond[verbatim,quote,relative=2] +\tempo "" 8 = 96 +d4 g e c +@end lilypond + + +@snippets + +@lilypondfile[verbatim,lilyquote,texidoc,doctitle] +{printing-metronome-and-rehearsal-marks-below-the-staff.ly} + +@c perhaps also an example of how to move it horizontally? + +@lilypondfile[verbatim,lilyquote,texidoc,doctitle] +{changing-the-tempo-without-a-metronome-mark.ly} + +@lilypondfile[verbatim,lilyquote,texidoc,doctitle] +{creating-metronome-marks-in-markup-mode.ly} + +Zu Einzelheiten siehe @ref{Text formatieren}. + + +@seealso +Glossar: +@rglos{metronome}, +@rglos{metronomic indication}, +@rglos{tempo indication}, +@rglos{metronome mark}. + +Notationsreferenz: +@ref{Text formatieren}, +@ref{MIDI-Ausgabe}. + +Schnipsel: +@rlsr{Staff notation}. + +Referenz der Interna: +@rinternals{MetronomeMark}. + + + + +@node Auftakte +@unnumberedsubsubsec Auftakte +@translationof Upbeats + +@cindex Auftakt +@cindex Takte verkürzen +@cindex partieller Takt +@cindex halber Takt +@cindex Taktlänge ändern + +@funindex measurePosition +@funindex \partial +@funindex partial + +Verkleinerte Takte, wie etwa ein Auftakt, werden mit dem +Befehl @code{\partial} notiert, dessen Syntax lautet: + +@example +\partial @var{Dauer} +@end example + +@noindent +wobei @var{Dauer} die rhythmische Länger der Noten darstellt, +die vor dem ersten vollständigen Takt gesetzt werden sollen: + +@lilypond[quote,verbatim,relative=2] +\partial 4 e4 | +a2. c,4 | +@end lilypond + +Intern wird @code{\partial @var{Dauer}} übersetzt nach: + +@example +\set Timing.measurePosition -@var{Länge der Dauer} +@end example + +Zum Beispiel wird aus @code{\partial 8*3}: + +@example +\set Timing.measurePosition = #(ly:make-moment -3 8) +@end example + +Die Eigenschaft @code{measurePosition} (Takt-Position) enthält +eine rationale Zahl, +die anzeigt, wie groß der Abstand zum Taktanfang ist. Deshalb ist +sie eine negative Zahl; @code{\partial 4} wird also intern übersetzt +zu @code{-4} was soviel bedeutet wie: @qq{Eine Viertel bleibt übrig vom ganzen Takt.} + +@seealso +Glossar: +@rglos{anacrusis}. + +Notationsreferenz: +@ref{Verzierungen}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{Timing_translator}. + +@cindex Kadenz und Zeilenumbruch +@cindex Kadenz und Seitenumbruch +@cindex Musik ohne Metrum, Umbrüche +@cindex nicht metrische Musik, Umbrüche +@cindex Umbrüche in nicht metrischer Musik +@cindex Umbrüche in Kadenzen +@cindex Zeilenumbrüche in Kadenzen +@cindex Seitenumbrüche in Kadenzen +@cindex Zeilenumbrüche in nicht metrischer Musik +@cindex Seitenumbrüche in nicht metrischer Musik + +@knownissues + +@code{\partial} ist nur für den Anfang eines Stückes vorgesehen. Wenn der +Befehl innerhalb eines Stückes verwendet wird, können seltsame Warnungen +auftreten. In solchem Fall sollten Sie @code{\set Timing.measurePosition} +benutzen. + + +@node Musik ohne Metrum +@unnumberedsubsubsec Musik ohne Metrum +@translationof Unmetered music + +@cindex Kadenz +@cindex Taktlinien, ausschalten +@cindex Taktnummern, ausschalten +@cindex Noten ohne Takt +@cindex Taktart, Noten ohne +@cindex Metrum, Noten ohne + +@funindex \cadenzaOn +@funindex \cadenzaOff +@funindex cadenzaOn +@funindex cadenzaOff + +Taktlinien und Taktzahlen werden automatisch erzeugt. Für Musik +ohne Metrum hingegen (etwa Kadenzen) ist das jedoch nicht +erwünscht. Mit den Befehlen @code{\cadenzaOn} und +@code{\cadenzaOff} kann dieses Verhalten ausgeschaltet und +wieder angeschaltet werden. + +@lilypond[verbatim,relative=2,quote] +c4 d e d +\cadenzaOn +c4 c d8[ d d] f4 g4. +\cadenzaOff +\bar "|" +d4 e d c +@end lilypond + +Taktnummerierung wird am Ende der Kadenz wieder aufgenommen, als +ob es die Kadenz nicht gegeben hätte: + +@lilypond[verbatim,relative=2,fragment] +% Show all bar numbers +\override Score.BarNumber #'break-visibility = #all-visible +c4 d e d +\cadenzaOn +c4 c d8[ d d] f4 g4. +\cadenzaOff +\bar "|" +d4 e d c +@end lilypond + +@cindex Bebalkung in Kadenzen +@cindex Bebalken in taktloser Musik +@cindex Kadenzen, Bebalkung +@cindex Balken in Kadenzen +@cindex Taktlose Musik, Bebalkung + +@lilypond[verbatim,relative=2,quote] +\repeat unfold 8 { c8 } +\cadenzaOn +\repeat unfold 5 { c8 } +\bar"|" +\cadenzaOff +\repeat unfold 8 { c8 } +@end lilypond + +Automatische Bebalkung wird durch @code{\cadenzeOn} ausgestellt und durch +@code{\cadenzaOff} wieder angestellt. Darum müssen alle Balken in Kadenzen +manuell eingegeben werden (siehe @ref{Manuelle Balken}). + +Diese vordefinierten Befehle wirken sich auf alle Systeme in der +Partitur aus, auch wenn sie nur in einer einzigen Stimme notiert werden. +Um dieses Verhalten zu ändern, müsen Sie @code{Timing_translator} +aus dem @code{Score}-Kontext in den @code{Staff}-Kontext verschieben, +wie gezeigt in @ref{Polymetrische Notation}. + +@predefined +@code{\cadenzaOn}, +@code{\cadenzaOff}. +@endpredefined + +@seealso +Glossar: +@rglos{cadenza}. + +Notationsreferenz: +@ref{Sichtbarkeit von Objekten}, +@ref{Polymetrische Notation} +@ref{Manuelle Balken}. + +Schnipsel: +@rlsr{Rhythms}. + +@knownissues + +LilyPond fügt Zeilen- und Seitenumbrüche nur an einer Taktlinie +ein. Wenn die Kadenz nicht vor einem Umbruch endet, müssen Sie +selber unsichtbare Taktlinien mit + +@example +\bar "" +@end example + +@noindent +einfügen, um anzuzeigen, wo umgebrochen werden darf. + +Sie müssen explizit einen @code{Voice}-Kontext erstellen, wenn +Sie ein Stück mit @code{cadenzaOn} beginnen wollen, weil sonst +ein seltsamer Fehler auftreten kann. + +@example +\new Voice @{ + \relative c' @{ + \cadenzaOn + c16[^"Solo Free Time" d e f] g2. + \bar "||" + \cadenzaOff + @} +@} +@end example + + +@node Polymetrische Notation +@unnumberedsubsubsec Polymetrische Notation +@translationof Polymetric notation + +@cindex doppelte Taktartensymbole +@cindex Taktartensymbole, doppelt +@cindex Taktartensymbole, unterteilt +@cindex Taktarten, polymetrisch +@cindex polymetrische Taktarten +@cindex Metrum, polymetrisch +@cindex unterteilte Taktarten + +@funindex timeSignatureFraction +@funindex \scaleDurations +@funindex scaleDurations +@funindex \times +@funindex times + +Polymetrische Notation ist unterstützt, entweder direkt, oder +indem man das sichtbare Taktart-Symbol verändert und zusätzlich +die Notendauern skaliert. + +@strong{@i{Systeme mit unterschiedlichen Taktarten, gleiche +Taktlänge}} + +Diese Art der Notation kann erstellt werden, indem für jedes +System eine identische Taktart eingestellt wird, aber manuell +für jeden Takt durch Einstellung von @code{timeSignatureFraction} +auf den gewünschten Bruch geändert und dann die Länge der +Noten entsprechenden skaliert wird, siehe auch @ref{Taktangabe}. +Die Skalierung geschieht mit dem Befehl +@code{\scaleDurations}, der auf ähnliche Weise wie @code{\times} +benutzt wird, aber keine Klammer über den Noten ausgibt. Siehe +auch @ref{Tondauern skalieren}. + +@cindex Bebalkung in polymetrischer Notation +@cindex Polymetrische Notation und Balken +@cindex Balken in polymetrischer Notation + +In diesem Beispiel werden Noten mit den Taktarten 3/4, 9/8 und +10/8 parallel benutzt. Im zweiten System werden die gezeigten +Dauern mit 2/3 multipliziert, da 2/3x9/8=3/4, und im dritten +System werden die gezeigten Dauern mit 3/5 multipliziert, da +3/5x10/8=3/4. Oft wird es nötig sein, Balken manuell zu setzen, +weil die Skalierung sich auch auf die automatische Bebalkung +auswirkt. + +@lilypond[quote,verbatim] +\relative c' << + \new Staff { + \time 3/4 + c4 c c | + c c c | + } + \new Staff { + \time 3/4 + \set Staff.timeSignatureFraction = #'(9 . 8) + \scaleDurations #'(2 . 3) + \repeat unfold 6 { c8[ c c] } + } + \new Staff { + \time 3/4 + \set Staff.timeSignatureFraction = #'(10 . 8) + \scaleDurations #'(3 . 5) { + \repeat unfold 2 { c8[ c c] } + \repeat unfold 2 { c8[ c] } | + c4. c4. \times 2/3 { c8[ c c] } c4 + } + } +>> +@end lilypond + +@strong{@i{Systeme mit unterschiedlichen Taktarten, unterschiedliche +Taktlänge}} + +Jedes System kann auch eine eigene unabhängige Taktart erhalten. +Dazu muss der @code{Timing_translator} und der +@code{Default_bar_line_engraver} in den @code{Staff}-Kontext +verschoben werden. + +@lilypond[quote,verbatim] +\layout { + \context { + \Score + \remove "Timing_translator" + \remove "Default_bar_line_engraver" + } + \context { + \Staff + \consists "Timing_translator" + \consists "Default_bar_line_engraver" + } +} + +% Now each staff has its own time signature. + +\relative c' << + \new Staff { + \time 3/4 + c4 c c | + c4 c c | + } + \new Staff { + \time 2/4 + c4 c | + c4 c | + c4 c | + } + \new Staff { + \time 3/8 + c4. | + c8 c c | + c4. | + c8 c c | + } +>> +@end lilypond + +@snippets + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{compound-time-signatures.ly} + + +@seealso +Glossar: +@rglos{polymetric}, +@rglos{polymetric time signature}, +@rglos{meter}. + +Notationsreferenz: +@ref{Taktangabe}, +@ref{Tondauern skalieren}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{TimeSignature}, +@rinternals{Timing_translator}, +@rinternals{Default_bar_line_engraver}, +@rinternals{Staff}. + +@knownissues + +Wenn unterschiedliche Taktarten parallel benutzt werden, werden +Noten auf demselben musikalischen Moment horizontal auf die +gleiche Position gesetzt. Die unterschiedlichen Taktlinien +führen allerdings dazu, dass die Noten nicht ganz so regelmäßig +gesetzt werden, wie es ohne unterschiedliche Taktarten der +Fall wäre. + + +@node Automatische Aufteilung von Noten +@unnumberedsubsubsec Automatische Aufteilung von Noten +@translationof Automatic note splitting + +@cindex Noten, Aufteilen +@cindex Aufteilen von Noten +@cindex automatisches Aufteilen von Noten +@cindex Pausen, Aufteilen +@cindex Aufteilen von Pausen + +@funindex Note_heads_engraver +@funindex Completion_heads_engraver +@funindex Completion_rest_engraver + +Lange Noten, die über Taktlinien hinüberreichen, können +automatisch in übergebundene Noten aufgeteilt werden. +Dieses Verhalten erreicht man, indem der @rinternals{Note_heads_engraver} +mit dem @rinternals{Completion_heads_engraver} ausgetauscht wird. Auf +gleiche Art können lange Pausen, die über Taktgrenzen reichen, automatisch +aufgeteilt werden, indem man den @code{Rest_engraver}mit dem +@code{Completion_rest_engraver} ersetzt. Im nächsten Beispiel werden +Noten und Pausen, die über die Taktlinie dauern, aufgeteilt; Noten +werden auch übergebunden. + +@lilypond[quote,verbatim,relative=1] +\new Voice \with { + \remove "Note_heads_engraver" + \consists "Completion_heads_engraver" + \remove "Rest_engraver" + \consists "Completion_rest_engraver" +} + +{ c2. c8 d4 e f g a b c8 c2 b4 a g16 f4 e d c8. c2 r1*2 } +@end lilypond + +Dieser Engraver teilt alle Noten und Pausen +auf, die über eine Taktlinie dauern und fügt für Noten Bindebögen hinzu. +Er kann unter Anderem dann nützlich sein, wenn man komplexe +Partituren auf Fehler überprüfen möchte: Wenn die Takte nicht +vollständig gefüllt sind, zeigt die Überbindung genau an, wie viele +Notenwerte noch in dem jeweiligen Takt fehlen. + +@seealso +Glossar: +@rglos{tie} + +Handbuch zum Lernen: +@rlearning{Was sind Engraver?}, +@rlearning{Engraver hinzufügen und entfernen}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{Note_heads_engraver}, +@rinternals{Completion_heads_engraver}, +@rinternals{Rest_engraver}, +@rinternals{Completion_rest_engraver}. +@rinternals{Forbid_line_break_engraver}. + +@knownissues + +Nicht alle Notenwerte (besonders wenn sie andere rhythmische +Aufteilungen beinhalten) können exakt durch normale Noten und +Punktierungen wiedergegeben werden. Der Engraver setzt aber +trotzdem keine Triolen etc. + +@code{Completion_heads_engraver} wirkt sich nur auf Noten aus; +Pausen werden nicht aufgeteilt. + + +@node Melodierhythmus anzeigen +@unnumberedsubsubsec Melodierhythmus anzeigen +@translationof Showing melody rhythms + +@cindex Melodierhythmus: Anzeige +@cindex Rhythmus der Melodie anzeigen + +Manchmal soll nur der Rhythmus einer Melodie dargestellt werden. Das +erreicht man mit einem Rhythmus-Notensystem. Alle Tonhöhen werden +auf eine Linie reduziert und das System hat auch nur eine einzige +Linie. + +@lilypond[quote,relative=1,verbatim] +<< + \new RhythmicStaff { + \new Voice = "myRhythm" { + \time 4/4 + c4 e8 f g2 + r4 g g f + g1 + } + } + \new Lyrics { + \lyricsto "myRhythm" { + This is my song + I like to sing + } + } +>> +@end lilypond + +@cindex Gitarren-Akkordnotation +@cindex Schlagrhythmus, Gitarre +@cindex Gitarrenschlagrhythmus, Notation + +@funindex Pitch_squash_engraver +@funindex \improvisationOn +@funindex improvisationOn +@funindex \improvisationOff +@funindex improvisationOff + +Akkordnotation für Gitarren bezeichnet auch oft zusätzlich den +geschlagenen Rhythmus. Das kann notiert werden unter Verwendung +des @code{Pitch_squash_engraver} und indem Tonhöhenimprovisation +eingeschaltet wird mit @code{\improvisationOn}. + +@lilypond[quote,verbatim] +<< + \new ChordNames { + \chordmode { + c1 f g c + } + } + + \new Voice \with { + \consists Pitch_squash_engraver + } \relative c'' { + \improvisationOn + c4 c8 c c4 c8 c + f4 f8 f f4 f8 f + g4 g8 g g4 g8 g + c4 c8 c c4 c8 c + } +>> +@end lilypond + +@predefined +@code{\improvisationOn}, +@code{\improvisationOff}. +@endpredefined + +@snippets + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{guitar-strum-rhythms.ly} + +@seealso +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{RhythmicStaff}, +@rinternals{Pitch_squash_engraver}. + + + +@node Balken +@subsection Balken +@translationof Beams + +@menu +* Automatische Balken:: +* Einstellung von automatischen Balken:: +* Manuelle Balken:: +* Gespreizte Balken:: +@end menu + + +@node Automatische Balken +@unnumberedsubsubsec Automatische Balken +@translationof Automatic beams + +LilyPond setzt Balken (engl. beam) automatisch. + +@cindex Balken, Einstellungen +@cindex Balken, eigene Regeln +@cindex automatische Bebalkung +@cindex Balken, automatisch +@cindex eigene Balkenregeln + +@funindex \autoBeamOn +@funindex autoBeamOn +@funindex \autoBeamOff +@funindex autoBeamOff + +@lilypond[quote,verbatim,relative=2] +\time 2/4 c8 c c c +\time 6/8 c8 c c c8. c16 c8 +@end lilypond + +Wenn diese automatischen Entscheidungen nicht gut genug sind, können +die Balken auch explizit eingegeben werden, siehe +@ref{Manuelle Balken}. Balken @emph{müssen} auch auf diese Weise eingegeben +werden, wenn sie über Pausen hinwegreichen sollen. + +Wenn automatische Bebalkung nicht benötigt wird, kann sie mit dem Befehl @code{\autoBeamOff} +aufgehoben werden und mit dem Befehl @code{\autoBeamOn} wieder +eingeschaltet werden. + +@lilypond[quote,relative=1,verbatim] +c4 c8 c8. c16 c8. c16 c8 +\autoBeamOff +c4 c8 c8. c16 c8. +\autoBeamOn +c16 c8 +@end lilypond + +@cindex Melismen, Balken +@cindex Balken und Melismen + +@warning{Wenn Balken eingesetzt werden, um Melismen in Gesang zu notieren, +sollte die automatische Bebalkung mit @code{\autoBeamOff} ausgeschaltet +werden und die Balken manuell notiert werden.} + +@warning{Wenn @code{@bs{}partcombine} mit @code{@bs{}autoBeamOff} benutzt +wird, können ungewünschte Resultate auftreten. Siehe die Schnipsel unten +für mehr Information.} + +Balkenmuster, die sich von den automatisch erstellen unterscheiden, +können erstellt werden, siehe @ref{Einstellung von automatischen Balken}. + +@predefined +@code{\autoBeamOff}, +@code{\autoBeamOn}. +@endpredefined + + + +@funindex breakable + +@cindex Zeilenumbruch, Balken +@cindex Balken, Zeilenumbrüche +@cindex Balken mit Knie +@cindex weit außeinander liegende Balken +@cindex auto-knee-gap + +@snippets +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{beams-across-line-breaks.ly} + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{changing-beam-knee-gap.ly} + +@cindex Balken, \partcombine und \autoBeamOff +@cindex Stimmen, \autoBeamOff und \partcombine + +@lilypondfile [verbatim, lilyquote, ragged-right, texidoc, doctitle] +{partcombine-and-autobeamoff.ly} + +@seealso +Notationsreferenz: +@ref{Manuelle Balken}, +@ref{Einstellung von automatischen Balken}. + +Installierte Dateien: +@file{scm/auto-beam.scm}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{Auto_beam_engraver}, +@rinternals{Beam_engraver}, +@rinternals{Beam}, +@rinternals{BeamEvent}, +@rinternals{BeamForbidEvent}, +@rinternals{beam-interface}, +@rinternals{unbreakable-spanner-interface}. + + +@node Einstellung von automatischen Balken +@unnumberedsubsubsec Einstellung von automatischen Balken +@translationof Setting automatic beam behavior + +@cindex autobeam +@cindex Verändern von automatischer Bebalkung +@cindex Bebalkung, automatisch, Einstellungen +@cindex Text und Balken +@cindex Gesangstext und Balken +@cindex Balken und Gesangstext + +@funindex autoBeaming +@funindex beatStructure +@funindex beamExceptions +@funindex measureLength +@funindex baseMoment +@funindex \time +@funindex time +@funindex \set +@funindex set + +In den meisten Fällen enden automatische Balken am Ende eines Taktes. +Die Endpunkte für Schläge werden durch die Kontexteigenschaften +@code{baseMoment} und @code{beatStructure} bestimmt. @code{beatStructure} +ist eine Scheme-Liste, die die Länge jedes Schlages im Takt in +Einheiten von @code{baseMoment} angibt. Der Standard von +@code{baseMoment} ist Eins durch den Numerator der Taktangabe. Der +Standardwert jeder Längeneinheit @code{baseMoment} ist ein +einzelner Taktschlag. + + +@lilypond[quote,relative=2,verbatim] +\time 5/16 +c16^"default" c c c c | +\set Timing.beatStructure = #'(2 3) +c16^"(2+3)" c c c c | +\set Timing.beatStructure = #'(3 2) +c16^"(3+2)" c c c c | +@end lilypond + +Balkenregelveränderungen können auf bestimmte Kontexte beschränkt +werden. Wenn keine Regeln in einen unteren Kontext definiert +sind, gelten die Regeln des höheren Kontext, in dem sich der +niedrigere befindet. + +@lilypond[quote, verbatim,relative=1] +\new Staff << + \time 7/8 + \set Staff.beatStructure = #'(2 3 2) + \new Voice = one { + \relative c'' { + a8 a a a a a a + } + } + \new Voice = two { + \relative c' { + \voiceTwo + \set Voice.beatStructure = #'(1 3 3) + f8 f f f f f f + } + } +>> +@end lilypond + +Wenn mehrere Stimmen eingesetzt werden, muss der @code{Staff}-Kontext +definiert werden, wenn die Balkenregeln auf alle Stimmen des +Systems angewendet werden sollen: + +@lilypond[quote,verbatim,relative=2] +\time 7/8 +% rhythm 3-1-1-2 +% Context applied to Voice by dafault -- does not work correctly +% Because of autogenerated voices, all beating will +% be at baseMoment (1 . 8) +\set beatStructure = #'(3 1 1 2) +<< {a8 a a a16 a a a a8 a} \\ {f4. f8 f f f} >> + +% Works correctly with context Staff specified +\set Staff.beatStructure = #'(3 1 1 2) +<< {a8 a a a16 a a a a8 a} \\ {f4. f8 f f f} >> +@end lilypond + +Der Wert von @code{baseMoment} kann angepasst werden, um das +Bebalkungsverhalten zu ändern, wenn gewünscht. In diesem Fall +muss der Wert von @code{beatStructure} so gesetzt werden, dass +er kompatibel mit dem neuen Wert von @code{baseMoment} ist. + +@lilypond[quote,verbatim,relative=2] +\time 5/8 +\set Timing.baseMoment = #(ly:make-moment 1 16) +\set Timing.beatStructure = #'(7 3) +\repeat unfold 10 { a16 } +@end lilypond + +@code{baseMoment} ist ein @i{Moment}, eine Einheit an musikalischer +Dauer. Eine Anzahl vom Typus @i{Moment} wird durch die Scheme-Funktion +@code{ly:make-moment} erstellt. Zu mehr Information über diese Funktion +siehe @ref{Verwaltung der Zeiteinheiten}. + +Der Standardwert von @code{baseMoment} ist Eins durch den Denominator +der Taktangabe. Alle Ausnahmen dieses Standards finden sich in der Datei +@file{scm/time-signature-settings.scm}. + +Besondere automatische Bebalkungsregeln (außer dass ein Balken auf einem +Taktschlag aufhört) sind in der @code{beamExceptions}-Eigenschaft +definiert. + +@lilypond[quote,relative=2,verbatim] +\time 3/16 +\set Timing.beatStructure = #'(2 1) +\set Timing.beamExceptions = + #'( ;start of alist + (end . ;entry for end of beams + ( ;start of alist of end points + ((1 . 32) . (2 2 2)) ;rule for 1/32 beams -- end each 1/16 + ))) %close all entries +c16 c c | +\repeat unfold 6 { c32 } | +@end lilypond + +@code{beamExceptions} ist eine Aliste mit einem Schlüssel der Regeltypen +(rule-type) und einem Wert der Bebalkungsregeln (beaming-rules). + +Im Moment ist der einzige mögliche rule-type @code{#'end} für ein +Balkenende. + +Beaming-rules ist eine Scheme-Aliste (oder eine paarige Liste), die +den Balkentyp und die Gruppierung anzeigt, die auf Balken angewendet +werden, welche Noten mit einer kürzesten Dauer des Balkentyps enthalten. + +@example +#'((beam-type1 . grouping-1) + (beam-type2 . grouping-2) + (beam-type3 . grouping-3)) +@end example + +Beam-type ist ein Scheme-Paar, das die Dauer eines Balkens anzeigt, +etwa @code{(1 . 16)} für ein Sechszehntel. + +Grouping ist eine Scheme-Liste, die die auf den Balken anzuwendene +Gruppierung anzeigt. Die Gruppierung wird in Einheiten des +Balkentyps angegeben. + +@warning{Ein @code{beamExceptions}-Wert muss eine @emph{vollständige} +Ausnahme-Liste sein. Das heißt, dass jede Ausnahme, die angewendet werden +soll, auch in die Einstellungen mit aufgenommen werden muss. Es ist nicht +möglich, nur eine der Einstellungen zu ändern, zu entfernen oder hinzuzufügen. +Das mag seltsam erscheinen, bedeutet aber, dass die aktuellen +Balkenregeln bekann sein müssen, um ein neues Bebalkungsmuster definieren zu können.} + +Wenn die Taktart geändert wird, werden neue Standardwerte für +@code{Timing.baseMoment}, @code{Timing.beatStructure} und +@code{Timing.beamExceptions} definiert. Wenn die Taktart +definiert wird, werden die automatischen Bebalkungsregeln für den +@code{Timing}-Kontext auf den Standard zurückgesetzt. + +@lilypond[quote,verbatim,relative=2] +\time 6/8 +\repeat unfold 6 { a8 } +% group (4 + 2) +\set Timing.beatStructure = #'(4 2) +\repeat unfold 6 { a8 } +% go back to default behavior +\time 6/8 +\repeat unfold 6 { a8 } +@end lilypond + +Die automatischen Standardeinstellungen für die Bebalkung einer +Taktart werden in der Datei @file{scm/time-signature-settings.scm} +bestimmt. Änderungen der automatischen Bebalkungsregeln für eine Taktart +werden in @ref{Taktangabe} beschrieben. + +Die meisten automatischen Bebalkungsregeln für eine Taktart enthalten einen +Eintrag für @code{beamExceptions}. Beispielsweise wird in einem 4/4-Takt +versucht, den Takt in zwei Hälfen zu teilen, wenn nur Achtelnoten vorkommen. +Die @code{beamExceptions}-Regel kann die @code{beatStructure}-Einstellung +überschreiben, wenn @code{beamExceptions} nicht zurückgesetzt wird: + +@lilypond[quote,verbatim,relative=2] +\time 4/4 +\set Timing.baseMoment = #(ly:make-moment 1 8) +\set Timing.beatStructure = #'(3 3 2) +% This won't beam (3 3 2) because of beamExceptions +\repeat unfold 8 {c8} | +% This will beam (3 3 2) because we clear beamExceptions +\set Timing.beamExceptions = #'() +\repeat unfold 8 {c8} +@end lilypond + +Auf die gleiche Art werden im 3/4-Takt Achtelnoten als ganzer Takt bebalkt. +Um Achtelnoten im 3/4-Takt auf jeder Taktzeit zu bebalken, muss +@code{beamExceptions} zurückgesetzt werden: + +@lilypond[quote,verbatim,relative=2] +\time 3/4 +% by default we beam in (3) due to beamExceptions +\repeat unfold 6 {a8} | +% This will beam (1 1 1) due to beatLength +\set Timing.beamExceptions = #'() +\repeat unfold 6 {a8} +@end lilypond + +@i{@strong{Wie die automatische Bebalkung funktioniert}} + +Wenn die automatische Bebalkung aktiviert ist, wird die Platzierung +der automatischen Balken durch die Kontexteigenschaften +@code{baseMoment}, @code{beatStructure} und @code{beamExceptions} +bestimmt. + +Die folgenden Regeln, in der Reihenfolge ihrer Priorität, gelten, wenn das Aussehen der Balken bestimmt wird: + +@itemize + +@item +Wenn ein manueller Balken mit @code{[...]} definiert ist, wird er gesetzt, andernfalls + +@item +wenn eine Balkenendung-Regel für den Balkentyp in +@code{beamExceptions} definiert ist, wird sie verwendet, um die +gültigen Plätze für Balkenenden zu berechnen, andernfalls + +@item +wenn eine Balkenendung-Regel für einen größeren Balkentyp +in @code{beamExceptions} definiert ist, wird sie verwendet, +um die gültigen Plätze für Balkenenden zu berechnen, andernfalls + +@item +benutze die Werte von @code{baseMoment} und @code{beatStructure}, +um die Enden der Balken im Takt zu definieren und beende Balken +am Ende jedes Taktes. + +@end itemize + +In den oben genannten Regeln ist der Balkentyp die Dauer der +kürzesten Note der bebalkten Gruppe. + +Die Standardbebalkungsregeln finden sich in der Datei +@file{scm/time-signature-settings.scm}. + + +@snippets + +@cindex Balken, Unterteilung + +@funindex subdivideBeams + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{subdividing-beams.ly} + +@cindex Taktgruppen +@cindex Schlaggruppen +@cindex Taktschläge gruppieren +@cindex Takt unterteilen +@cindex Unterteilen von Takten + +@funindex autoBeamSettings + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{conducting-signs,-measure-grouping-signs.ly} + +@cindex Balken, letzter in Partitur +@cindex Balken, letzter in polyphoner Stimme + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{beam-endings-in-score-context.ly} + +@seealso +Installierte Dateien: +@file{scm/beam-settings.scm}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{Auto_beam_engraver}, +@rinternals{Beam}, +@rinternals{BeamForbidEvent}, +@rinternals{beam-interface}. + + +@knownissues +Wenn eine Partitur endet, während ein automatischer Balken noch +nicht beendet wurde und weiterhin Noten erwartet, wird dieser +letzte Balken nicht ausgegeben. Das Gleiche gilt auch für +polyphone Stimmen, die mit der +@code{<< @dots{} \\ @dots{} >>}-Konstruktion notiert wurden. Wenn eine +polyphone Stimme endet, während ein Balken noch weitere Noten +erwartet, wird der Balken nicht gesetzt. Eine Notlösung für +dieses Probelm ist, den letzten Balken in der Stimme oder +Partitur manuell zu setzen. + +Die Standardeinstellungen weisen den dem +@code{Score}-Kontext zu. Das bedeutet, dass das Setzen der +Taktart (time signature) in einem System sich auch auf die Bebalkung +der anderen Systeme auswirkt. Darum verändert eine neue Taktart in einem +späteren System auch alle früher vorgenommenen eigenen Einstellungen +der Bebalkung eines anderen Systems. Eine Möglichkeit, dieses Problem zu +vermeiden, ist es, die Taktart nur in einem System zu setzen. + +@lilypond[quote,verbatim,relative=2] +<< + \new Staff { + \time 3/4 + \set Timing.baseMoment = #(ly:make-moment 1 8) + \set Timing.beatStructure = #'(1 5) + \repeat unfold 6 { a8 } + } + \new Staff { + \repeat unfold 6 { a8 } + } +>> +@end lilypond + +Die Standardbebalkungsregeln für die Taktart können auch verändert +werden, sodass die gewünschte Bebalkung immer benützt wird. Veränderungen +der automatischen Bebalkungsregeln für eine Taktart sind in +@ref{Taktangabe} beschrieben. + +@lilypond[quote,verbatim,relative=2] +<< + \new Staff { + \overrideTimeSignatureSettings + #'(3 . 4) % timeSignatureFraction + #'(1 . 8) % baseMomentFraction + #'(1 5) % beatStructure + #'() % beamExceptions + \time 3/4 + \repeat unfold 6 { a8 } + } + \new Staff { + \time 3/4 + \repeat unfold 6 { a8 } + } +>> +@end lilypond + + +@node Manuelle Balken +@unnumberedsubsubsec Manuelle Balken +@translationof Manual beams + +@cindex manuelle Balken +@cindex Balken, manuell + +@funindex ] +@funindex [ + +In einigen Fällen kann es nötig sein, den automatischen Algorithmus +für die Balken zu überschreiben. Die automatischen Balken werden +beispielsweise nicht über Pausen oder Taktlinien hinweg gesetzt, und +in Gesang werden die Balken oft nach dem Rhythmus des Textes und +nicht dem der Musik gesetzt. +Manuell definierte Balken werden mit den Zeichen @code{[} und +@code{]} (AltGr+8 bzw. 9) markiert. + +@lilypond[quote,relative=1,verbatim] +r4 r8[ g' a r] r g[ | a] r +@end lilypond + +@cindex manuelle Balken, Richtung zuweisen +@cindex manuelle Balken, Verzierungen +@cindex Verzierungen, manuelle Bebalkung + +Die Richtung von Balken kann mit den Richtungszeichen verändert werden: + +@lilypond[quote,relative=2,verbatim] +c8^[ d e] c,_[ d e f g] +@end lilypond + +@funindex \noBeam +@funindex noBeam + +Einzelne Noten können mit dem Befehl @code{\noBeam} markiert werden, +damit sie nicht mit einem Balken versehen werden. + +@lilypond[quote,ragged-right,fragment,verbatim,relative=2] +\time 2/4 c8 c\noBeam c c +@end lilypond + +Balken von Verzierungsnoten und normale Balken können gleichzeitig +gesetzt werden. Unbebalkte Verzierungen werden nicht innerhalb von +normalen Balken gesetzt. + +@lilypond[quote,verbatim,relative=2] +c4 d8[ +\grace { e32[ d c d] } +e8] e[ e +\grace { f16 } +e8 e] +@end lilypond + +@funindex stemLeftBeamCount +@funindex stemRightBeamCount + +Noch bessere manuelle Kontrolle über die Balken kann durch Setzen +der Eigenschaften @code{stemLeftBeamCount} und +@code{stemRightBeamCount} erreicht werden. Sie bestimmen +die Anzahl von Balken, die rechts und links vom Hals der nächsten +Note gesetzt werden sollen. Wenn eine Eigenschaften gesetzt ist, +wird ihr Wert nur einmal eingesetzt und dann wieder auf Null gesetzt. +Im folgenden Beispiel hat das letzte @code{f} nur einen Balken +an seiner linken Seite (der als Achtelbalken der gesamten +Gruppe gewertet wird). + +@lilypond[quote,relative=2,verbatim] +a8[ r16 f g a] +a8[ r16 +\set stemLeftBeamCount = #2 +\set stemRightBeamCount = #1 +f16 +\set stemLeftBeamCount = #1 +g16 a] +@end lilypond + +@snippets + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{flat-flags-and-beam-nibs.ly} + +@seealso +Notationsreferenz: +@ref{Richtung und Platzierung}, +@ref{Verzierungen}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{Beam}, +@rinternals{BeamEvent}, +@rinternals{Beam_engraver}, +@rinternals{beam-interface}, +@rinternals{Stem_engraver}. + + +@node Gespreizte Balken +@unnumberedsubsubsec Gespreizte Balken +@translationof Feathered beams + +@cindex Balken, gespreizt +@cindex gespreizte Balken + +@funindex featherDurations +@funindex \featherDurations +@funindex grow-direction + +Gespreizte Balken werden teilweise eingesetzt um anzuzeigen, dass +kleine Notengruppen in beschleunigendem oder verlangsamendem Tempo +gespielt werden sollen, ohne dass sich das Tempo des Stückes +verändert. Die Reichweite der gespreizten Balken muss manuell +mit @code{[} und @code{]} angegeben werden und die Spreizung wird +kontrolliert, indem der Balken-Eigenschaft @code{grow-direction} +eine Richtung zugewiesen wird. + +Wenn die Anordnung der Noten und die MIDI-Ausgabe das @emph{Ritardando} +oder @emph{Accelerando}, wie es die Spreizung angibt, reflektieren soll, +müssen die Noten als ein musikalischer Ausdruck notiert werden, +der von geschweiften Klammern umgeben ist und dem ein +@code{featheredDurations}-(gespreizteDauern)-Befehl vorangestellt +ist, der das Verhältnis der ersten und letzten Dauer definiert. + +Die eckigen Klammern geben die Reichweite des Balkens an und die +geschweiften Klammern zeigen, auf welche Noten sich die Veränderung +der Dauern auswirkt. Normalerweise bezieht sich das auf die +selbe Notengruppe, aber das ist nicht unbedingt erforderlich: beide +Befehle sind unabhängig voneinander. + +Im folgenden Beispiel nehmen die acht 16-Noten exakt die gleiche +Zeit ein wie eine halbe Note, aber die erste Note ist halb so lang +wie die letzte der Gruppe, und die Noten dazwischen werden stufenweise +verlängert. Die ersten vier 32-Noten beschleunigen stufenweise +das Tempo, während die darauffolgenden vier 32-Noten ein +gleichmäßiges Tempo haben. + +@lilypond[relative=1,verbatim,quote] +\override Beam #'grow-direction = #LEFT +\featherDurations #(ly:make-moment 2 1) +{ c16[ c c c c c c c] } +\override Beam #'grow-direction = #RIGHT +\featherDurations #(ly:make-moment 2 3) +{ c32[ d e f] } +% revert to non-feathered beams +\override Beam #'grow-direction = #'() +{ g32[ a b c] } +@end lilypond + +@noindent +Die Platzierung der Noten im Druckbild entspricht den Notendauern +nur annähernd, aber die MIDI-Ausgabe ist exakt. + +@predefined +@code{\featherDurations}. +@endpredefined + +@seealso +Snippets: +@rlsr{Rhythms}. + +@knownissues + +Der @code{\featherDurations}-Befehl funktioniert nur mit kurzen +Notenabschnitten, und wenn die Zahlen in den Brüchen klein +sind. + + +@node Takte +@subsection Takte +@translationof Bars + +@menu +* Taktstriche:: +* Taktzahlen:: +* Takt- und Taktzahlüberprüfung:: +* Übungszeichen:: +@end menu + +@node Taktstriche +@unnumberedsubsubsec Taktstriche +@translationof Bar lines + +@c wrong word on purpose here: +@cindex Taktlinien +@cindex Taktstriche +@cindex Doppellinie +@cindex schließende Taktstriche +@cindex Taktstriche, schließend +@cindex Doppelter Taktstrich +@cindex Taktstrich, doppelt +@cindex Wiederholungszeichen + +@funindex \bar +@funindex bar + +Taktstriche trennen Takte voneinander, werden aber auch verwendet, +um Wiederholungen anzuzeigen. Normalerweise werden sie automatisch +nach Vorgabe der aktuellen Taktart eingefügt. + +Die einfachen, automatisch eingefügten Taktstriche können mit dem +@code{\bar}-Befehl geändert werden. Eine doppelter Taktstrich etwa +wird normalerweise am Ende eines Stückes gesetzt: + +@lilypond[quote,relative=1,verbatim] +e4 d c2 \bar "|." +@end lilypond + +Es ist kein Fehler, wenn die letzte Note in einem Takt nicht +zum automatisch eingefügten Taktstrich aufhört: es wird angenommen, +dass die Note im nächsten Takt weitergeht. Wenn aber eine ganze +Reihe solcher überlappenden Takte auftritt, können die Noten +gedrungen aussehen oder sogar über den Seitenrand hinausragen. Das +kommt daher, dass Zeilenumbrüche nur dann vorgenommen werden, wenn +ein vollständiger Takt auftritt, also ein Takt, an dem alle Noten +vor dem Taktstrich zu Ende sind. + +@warning{Eine falsche Dauer kann bewirken, dass Zeilenumbrüche +verhindert werden, woraus resultiert, dass die Noten entweder +sehr stark gedrängt auf der Zeile notiert werden, oder die Zeile +über den Seitenrand hinausragt.} + +@cindex Zeilenumbrüche +@cindex unsichtbare Taktstriche +@cindex Taktstriche, unsichtbar +@cindex Taktlinien, unsichtbar + +Zeilenumbrüche werden erlaubt, wenn ein Taktstrich manuell eingefügt +wird, auch, wenn es sich um keinen vollständigen Takt handelt. Um +einen Zeilenumbruch zu erlauben, ohne den Taktstrich auszugeben, +kann + +@example +\bar "" +@end example + +@noindent +benutzt werden. Damit wird ein unsichtbarer Taktstrich an dieser Stelle eingefügt +und damit ein Zeilenumbruch erlaubt (aber nicht erzwungen), ohne +dass sich die Anzahl der Takte erhöhen würde. Um einen +Zeilenumbruch zu erzwingen, siehe +@ref{Zeilenumbrüche}. + +@cindex manuelle Taktstriche +@cindex Taktstriche, manuell +@cindex Taktlinie, manuell + +Diese Taktstrichart und auch andere besondere Taktstriche +können manuell an jeder Stelle in der Partitur eingefügt werden. +Wenn sie mit dem Ende eines Taktes übereinstimmen, wird der +automatische Taktstrich durch den manuellen ersetzt. Diese +manuellen Einfügungen haben keine Auswirkung auf die Zählung und +Position der folgenden automatischen Taktstriche. + +Dabe gilt zu beachten, dass manuell gesetzten Taktstriche nur +visuell sichtbar sind. Sie wirken sich auf keine der Eigenschaften +aus, die ein normaler Taktstrich beeinflussen würde, wie etwa +Taktzahlen, Versetzungszeichen, Zeilenumbrüche usw. Sie beeinflussen +auch nicht die Berechnung und Platzierung von weiteren automatischen +Taktstrichen. Wenn ein manueller Taktstrich dort gesetzt wird, wo +ein automatischer Taktstrich sowieso wäre, werden die Auswirkungen +des originalen Taktstriches nicht verändert. + +Manuell können zwei einfache Taktstriche und zusätzlich fünf Arten +eines doppelten Taktstriches gesetzt werden: + +@lilypond[quote,relative=1,verbatim] +f1 \bar "|" +f1 \bar "." +g1 \bar "||" +a1 \bar ".|" +b1 \bar ".|." +c1 \bar "|.|" +d1 \bar "|." +e1 +@end lilypond + +Zusätzlich gibt es noch punktierte und gestrichelte Taktstriche: + +@lilypond[quote,relative=1,verbatim] +f1 \bar ":" +g1 \bar "dashed" +a1 +@end lilypond + +@noindent +und fünf unterschiedliche Wiederholungstaktstriche: + +@lilypond[quote,relative=1,verbatim] +f1 \bar "|:" g \bar ":|:" a \bar ":|.|:" b \bar ":|.:" c \bar ":|" d +@end lilypond + +Zusätzlich kann eine Taktlinie mit einem einfachen Apostroph gesetzt werden: + +@lilypond[quote,relative=1,verbatim] +f1 \bar "|:" +g1 \bar ":|:" +a1 \bar ":|.|:" +b1 \bar ":|.:" +c1 \bar ":|" +e1 +@end lilypond + +Zusätzliche kann ein Taktstrich auch nur als kleines Komma gesetzt +werden: + +@lilypond[quote,relative=1,verbatim] +f1 \bar "'" +@end lilypond + +Derartige Apostrophe werden allerdings vor allem im gregorianischen +Choral eingesetzt, und es wird empfohlen, anstatt dessen +@code{\divisioMinima} zu benutzen, wie beschrieben im Abschnitt +@ref{Divisiones}. + +@cindex segno + +Für @emph{segno}-Zeichen innerhalb des Systems gibt es drei +Taktstricharten, die sich in ihrem Verhalten an Zeilenumbrüchen +unterscheiden: + +@lilypond[quote,relative=2,verbatim] +c4 c c c +\bar "S" +c4 c c c \break +\bar "S" +c4 c c c +\bar "|S" +c4 c c c \break +\bar "|S" +c4 c c c +\bar "S|" +c4 c c c \break +\bar "S|" +c1 +@end lilypond + +@cindex Wiederholungen + +Auch wenn die Taktlinien, die Wiederholungen angeben, manuell +eingefügt werden können, wird die Wiederholung dadurch nicht von +LilyPond erkannt. Wiederholte Stellen werden besser notiert, indem +man die Wiederholungs-Befehle einsetzt, die automatische die +richtigen Taktlinien setzen. Das ist beschrieben in@ref{Wiederholungszeichen}. + +Zusätzlich kann noch @code{"||:"} verwendet werden, dass sich +genauso wie @code{"|:"} verhält, außer bei Zeilenumbrüchen, wo ein +doppelter Taktstrich am Ende der Zeile ausgegeben wird und ein +öffnender Wiederholungsstrich am Anfang der nächsten Zeile. + +@lilypond[quote,relative=2,verbatim] +c4 c c c +\bar "||:" +c4 c c c \break +\bar "||:" +c4 c c c +@end lilypond + +Für Kombinationen von Wiederholungen mit dem segno-Zeichen gibt +es sechs verschiedene Variationen: + +@lilypond[quote,relative=2,verbatim] +c4 c c c +\bar ":|S" +c4 c c c \break +\bar ":|S" +c4 c c c +\bar ":|S." +c4 c c c \break +\bar ":|S." +c4 c c c +\bar "S|:" +c4 c c c \break +\bar "S|:" +c4 c c c +\bar ".S|:" +c4 c c c \break +\bar ".S|:" +c4 c c c +\bar ":|S|:" +c4 c c c \break +\bar ":|S|:" +c4 c c c +\bar ":|S.|:" +c4 c c c \break +\bar ":|S.|:" +c1 +@end lilypond + +In Partituren mit vielen Systemen wird ein @code{\bar}-Befehl in einem +System automatisch auf alle anderen Systeme angewendet. Die resultierenden +Taktstriche sind miteinander verbunden innerhalb einer Gruppe +(@code{StaffGroup}) oder einem Klaviersystem +(@code{PianoStaff} bzw. (@code{GrandStaff}). + +@lilypond[quote,relative=1,verbatim] +<< + \new StaffGroup << + \new Staff { + e4 d + \bar "||" + f4 e + } + \new Staff { \clef bass c4 g e g } + >> + \new Staff { \clef bass c2 c2 } +>> +@end lilypond + +@cindex Standardtaktstrich, Änderung +@cindex Taktstriche, Änderung von Standard + + +@snippets + +@funindex whichBar +@funindex defaultBarType +@funindex \bar +@funindex bar +@funindex bartype + +Der Befehl @code{\bar }@var{Taktart} ist eine Kurzform von: +@code{\set Timing.whichBar = }@var{Taktart}. Immer, wenn +@code{whichBar} auf einen Wert gesetzt wird, wird ein +Taktstrich dieses Typs erzeugt. + +Der automatisch erzeugte Taktstrich ist @code{"|"}. Das kann +jederzeit durch den Befehl @code{\set Timing.defaultBarType = } +@var{Taktstrichart} geändert werden. + +@seealso +Notationsreferenz: +@ref{Zeilenumbrüche}, +@ref{Wiederholungszeichen}, +@ref{Systeme gruppieren}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{BarLine} (erstellt auf @rinternals{Staff}-Ebene), +@rinternals{SpanBar} (über Systeme), +@rinternals{Timing_translator} (für Timing-Eigenschaften). + + + +@node Taktzahlen +@unnumberedsubsubsec Taktzahlen +@translationof Bar numbers + +@cindex Taktnummern +@cindex Nummerierung von Takten +@cindex Zahl eines Taktes +@cindex Taktzahlen + +@funindex currentBarNumber + +Taktzahlen werden standardmäßig zu Beginn eines jeden Systems +ausgegeben, ausgenommen ist die erste Zeile. Die Zahl selber +wird in der @code{currentBarNumber}-Eigenschaft gespeichert, die +normalerweise für jeden Takt aktualisiert wird. Sie kann aber auch +manuell gesetzt werden: + +@lilypond[verbatim,quote,fragment,relative=1] +c1 c c c +\break +\set Score.currentBarNumber = #50 +c1 c c c +@end lilypond + +@cindex Taktzahlen, gleichmäßige Abstände + +@funindex barNumberVisibility +@funindex BarNumber + +Taktnummern können in regelmäßigem Abstand ausgegeben werden, +anstatt dass sie nur am Beginn des Systems erscheinen. Um das +zu erreichen, muss die Standardeinstellung verändert werden, um +zu erlauben, dass Taktnummern an anderen Stellen als dem +Beginn von Systemen ausgegeben werden. Das wird mit der +Eigenschaft @code{break-visibility} von @code{BarNumber} vorgenommen. +Sie braucht drei Werte, die auf @code{#t} (wahr) oder @code{#f} +(falsch) gestellt werden können, womit angegeben wird, ob die +Taktnummer an der entsprechenden Stelle sichtbar ist. Die +Reihenfolge der Werte ist: @var{Ende der Zeile}, @var{Mitte +der Zeile} und @var{Beginn der Zeile}. Im folgenden +Beispiel werden die Taktlinien überall ausgegeben: + +@lilypond[verbatim,quote,relative=1] +\override Score.BarNumber #'break-visibility = #'#(#t #t #t) +\set Score.currentBarNumber = #11 +% Permit first bar number to be printed +\bar "" +c1 | c | c | c +\break +c1 | c | c | c +@end lilypond + + +@cindex Taktnummer, Form +@cindex Aussehen von Taktnummern + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{printing-the-bar-number-for-the-first-measure.ly} + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{printing-bar-numbers-at-regular-intervals.ly} + +@cindex Ausrichtung von Taktlinien +@cindex Taktlinien, Ausrichtung + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{printing-bar-numbers-inside-boxes-or-circles.ly} + +@lilypondfile[verbatim,lilyquote,texidoc,doctitle] +{aligning-bar-numbers.ly} + +@lilypondfile[verbatim,lilyquote,ragged-right,texidoc,doctitle] +{removing-bar-numbers-from-a-score.ly} + + +@seealso +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{BarNumber}, +@rinternals{Bar_number_engraver}. + +@cindex Taktnummern, Zusammenstöße +@cindex Zusammenstöße, Taktnummern + +@knownissues +Taktnummern können mit der oberen Ecke der Klammer zu Beginn des +Systems zusammenstoßen. Um das zu verhindert, kann die +@code{padding}-Eigenschaft von @code{BarNumer} verwendet werden, +um die Zahl zu verschieben. Für mehr Information siehe +@rinternals{StaffgGroup} und @rinternals{BarNumber}. + + +@node Takt- und Taktzahlüberprüfung +@unnumberedsubsubsec Takt- und Taktzahlüberprüfung +@translationof Bar and bar number checks + +@cindex Taktüberprüfung + +@funindex barCheckSynchronize +@funindex | + +Die Taktüberprüfung hilft, Fehler in den Notendauern zu entdecken. +Eine Taktüberprüfung wird mit dem Taktstrichsymbol @qq{|} (Taste AltGr+<) +eingegeben. Immer, wenn LilyPond bei der Ausgabe des Notendrucks +auf dieses Zeichen stößt, sollte hier in den Noten auch ein +Taktstrich erscheinen. Wenn das nicht der Fall ist, wird eine Warnung +ausgegeben. Im nächsten Beispiel resultiert die zweite Taktüberprüfung +in einer Fehlermeldung. + +@example +\time 3/4 c2 e4 | g2 | +@end example + +Taktüberprüfungen können auch in Gesangstexten verwendet werden: + +@example +\lyricmode @{ + \time 2/4 + Twin -- kle | Twin -- kle +@} +@end example + +Besonders in mehrstimmiger komplizierter Musik können +falschen Notenwerte die ganze Partitur durcheinander bringen. +Es lohnt sich also, die Fehlersuche damit zu beginnen, nicht bestandene +Taktüberprüfungen zu kontrollieren. + +Wenn aufeinander folgende Taktüberprüfungen mit dem gleichen +Abstand Fehler produzieren, wird eventuell nur die erste Warnung +ausgegeben. Damit wird die Warnung auf den Ursprung de Fehlers +fokussiert. + +@funindex | +@funindex pipeSymbol + +Es ist auch möglich, die Bedeutung des Symbols @code{|} (Pipe) +umzudefinieren, so dass hiermit eine andere Aktion als eine +Taktüberprüfung erreicht wird. +Das geschieht, indem man der Pipe (@code{pipeSymbol} einen musikalischen +Ausdruck zuweist. Im nächsten Beispiel wird @code{|} dazu +verwendet, eine doppelte Taktlinie auszugeben, woimmer man +das Zeichen auch setzt. Gleichzeitig hört das Zeichen auf, +als Taktüberprüfung zu funktionieren. + +@lilypond[quote,verbatim] +pipeSymbol = \bar "||" +{ + c'2 c' | + c'2 c' + c'2 | c' + c'2 c' +} +@end lilypond + +@funindex \barNumberCheck +@funindex barNumberCheck + +Wenn man größere Musikstücke kopiert, kann es hilfreich sein, wenn +LilyPond überprüft, ob die Taktnummer, in der Sie gerade kopieren, +mit der des Originales übereinstimmt. Das kann mit dem Befehl +@code{\barNumberCheck} folgenderweise überprüft werden: + +@verbatim +\barNumberCheck #123 +@end verbatim + +@noindent +Eine Warnung wird ausgegeben, wenn der interne Zähler +@code{currentBarNumber} von LilyPond +nicht mit dem Wert 123 übereinstimmt. + +@seealso +Schnipsel: +@rlsr{Rhythms}. + + +@node Übungszeichen +@unnumberedsubsubsec Übungszeichen +@translationof Rehearsal marks + +@cindex Übungszeichen +@cindex Abschnitte markieren +@cindex Markieren von Abschnitten + +@funindex mark +@funindex \mark + +Übungszeichen können mit dem @code{\mark}-Befehl ausgegeben werden: + +@lilypond[quote,verbatim,relative=2] +c1 \mark \default +c1 \mark \default +c1 \mark #8 +c1 \mark \default +c1 \mark \default +@end lilypond + +@noindent +Das Zeichen wird automatisch um einen Wert heraufgesetzt, wenn man +@code{\mark \default} benutzt, aber man kann auch eine Ganzzahl +als Argument einsetzen, wenn man das Zeichen manuell setzen will. +Der Wert, der eingesetzt werden soll, wird in der Eigenschaft +@code{rehearsalMark} gespeichert. + +@lilypond[quote,verbatim,relative=2] +c1 \mark \default +c1 \mark \default +c1 \mark #8 +c1 \mark \default +c1 \mark \default +@end lilypond + +@noindent +Der Buchstabe@tie{}@qq{I} wird ausgelassen, was den allgemeinen +Notensatzregeln entspricht. Wenn Sie dennoch den Buchstaben +@qq{I} benutzen, wollen, müssen Sie einen der folgenden Stile benutzen, +je nachdem, was für einen Übungszeichenstil Sie wollen (Buchstaben, +Buchstaben in einem Kasten, Buchstaben in einem Kreis). + +@example +\set Score.markFormatter = #format-mark-alphabet +\set Score.markFormatter = #format-mark-box-alphabet +\set Score.markFormatter = #format-mark-circle-alphabet +@end example + +@lilypond[quote,verbatim,relative=2] +\set Score.markFormatter = #format-mark-box-alphabet +c1 \mark \default +c1 \mark \default +c1 \mark #8 +c1 \mark \default +c1 \mark \default +@end lilypond + +@cindex Übungszeichen formatieren +@cindex Stil von Übungszeichen +@cindex Übungszeichenstil +@cindex Art der Übungszeichen +@cindex Zeichen, Übung: Formatierung +@cindex manuelles Übungszeichen +@cindex Formatierung von Übungszeichen + +Der Stil der Übungszeichen wird von der Eigenschaft @code{markFormatter} definiert. Das ist eine Funktion, die +das aktuelle Zeichen und den aktuellen Kontext als Argument +annimmt. Sie gibt dann ein Textbeschriftungsobjekt aus. Im +folgenden Beispiel ist @code{markFormatter} so definiert, dass +eine Zahl ausgegeben wird. Dann wird ein Übungszeichen in einem +Kasten produziert. + +@lilypond[quote,verbatim,relative=2] +\set Score.markFormatter = #format-mark-numbers +c1 \mark \default +c1 \mark \default +\set Score.markFormatter = #format-mark-box-numbers +c1 \mark \default +\set Score.markFormatter = #format-mark-circle-numbers +c1 \mark \default +\set Score.markFormatter = #format-mark-circle-letters +c1 +@end lilypond + +Die Datei @file{scm/translation-functions.scm} beinhaltet +die Definitionen für @code{format-mark-numbers} (erstelle-Zeichen-Nummern), +@code{format-mark-box-numbers} (erstelle-Zeichen-Kasten-Nummern), +@code{format-mark-letters} (erstelle-Zeichen-Buchstaben) und +@code{format-mark-box-letters} (erstelle-Zeichen-Kasten-Buchstaben). Sie können als Anleitung +für eigene Formatierungsfunktionen dienen. + +Die Funktionen @code{format-mark-barnumbers}, +@code{format-mark-box-barnumbers}und +@code{format-mark-circle-barnumbers} könenn eingesetzt werden, +um Taktnummern anstelle der fortlaufenden Zahlen bzw. Buchstaben +zu erhalten. + +Andere Übungszeichenstile können auch manuell gesetzt werden: + +@example +\mark "A1" +@end example + +@noindent +@code{Score.markFormatter} hat keine Auswirkungen auf solcherart +definierte Zeichen. Man kann aber auch mit @code{\markup} +Textbeschriftungsobjekte zu dem selbstdefinierten Zeichen +hinzufügen: + +@example +\mark \markup@{ \box A1 @} +@end example + +@cindex Segno +@cindex Coda +@cindex D.S. al Fine +@cindex Dal Segno +@cindex Fermate +@cindex Noten-Schriftzeichen +@cindex Schriftzeichen, Notenschrift +@cindex Musikbuchstaben + +@funindex \musicglyph +@funindex musicglyph + +Musikbuchstaben (wie etwa das Segno-Zeichen) können mit dem Befehl +@code{\musicglyph} als ein +@code{\mark}-Zeichen definierte werden: + +@lilypond[quote,verbatim,relative=1] +c1 \mark \markup { \musicglyph #"scripts.segno" } +c1 \mark \markup { \musicglyph #"scripts.coda" } +c1 \mark \markup { \musicglyph #"scripts.ufermata" } +c1 +@end lilypond + +@noindent +Siehe @ref{Die Feta-Schriftart}, wo alle Symbole gezeigt sind, die +mit dem Befehl @code{\musicglyph} ausgegeben werden können. + +Übliche Veränderungen der Positionierung von Übungszeichen finden +sich in @ref{Text formatieren}. Zu noch präzieserer Kontrolle +siehe @code{break-alignable-interface} in @ref{Objekte ausrichten}. + +@seealso +Notationsreferenz: +@ref{Die Feta-Schriftart}, +@ref{Text formatieren}, +@ref{Objekte ausrichten}. + +Installierte Dateien: +@file{scm/translation-functions.scm} beinhaltet die Definition +von @code{format-mark-numbers} und +@code{format-mark-letters}. Sie können als Anleitung für eigene +Funktionen benutzt werden. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{MarkEvent}, +@rinternals{Mark_engraver}, +@rinternals{RehearsalMark}. + + +@node Besondere rhythmische Fragen +@subsection Besondere rhythmische Fragen +@translationof Special rhythmic concerns + +@menu +* Verzierungen:: +* An Kadenzen ausrichten:: +* Verwaltung der Zeiteinheiten:: +@end menu + +@node Verzierungen +@unnumberedsubsubsec Verzierungen +@translationof Grace notes + +@funindex \grace +@funindex grace + +@cindex Verzierungen +@cindex Ziernoten +@cindex Vorhalt +@cindex Vorschlag +@cindex Ornamente + +Verzierungen, mit dem Befehl @code{\grace} notiert, sind ausgeschriebene +Ornamente. Sie werden in einer kleineren Schriftgröße gesetzt und nehmen +keine logische Zeit im Takt ein. + +@lilypond[quote,relative=2,verbatim] +c4 \grace c16 c4 +\grace { c16[ d16] } c2 +@end lilypond + +LilyPond hat auch Unterstützung für zwei besondere Verzierungen, +den Vorschlag (engl. acciaccatura) und den Vorhalt (engl appogiatura). + Der Vorschlag wird durch eine verkleinerte Note mit Schrägstrich +und Bogen notiert. Der Vorhalt dagegen ist eine Verzierung, die +einen bestimmten Notenwert der Hauptnote für sich beansprucht. +Er wird als verkleinerte Note ohne Schrägstrich notiert. + +@lilypond[quote,relative=2,verbatim] +\grace c8 b4 +\acciaccatura d8 c4 +\appoggiatura e8 d4 +\acciaccatura { g16[ f] } e4 +@end lilypond + +Die Position von Verzierungen ist zwischen Notensystemen +synchronisiert. Im nächsten Beispiel stehen im einen +System zwei 16-Noten für jede 8-Note des zweiten Systems: + +@lilypond[quote,relative=2,verbatim] +<< \new Staff { e2 \grace { c16[ d e f] } e2 } + \new Staff { c2 \grace { g8[ b] } c2 } >> +@end lilypond + +@funindex \afterGrace +@funindex afterGrace + +@cindex Verzierung, danach +@cindex Nachschlag + +Wenn Sie eine Note mit einer Verzierung abschließen wollen, müssen +Sie den @code{\afterGrace}-Befehl benutzen. Er benötigt zwei +Argumente: die Hauptnote und die Verzierung, die nach der +Hauptnote folgen soll: + +@lilypond[quote,verbatim,relative=2] +c1 \afterGrace d1 { c16[ d] } c1 +@end lilypond + +Damit wird die Verzierung mit einem Abstand von der Hauptnote +gesetzt, der 3/4 der Dauer der Hauptnote entspricht. Dieser +Standard kann durch Definition von @code{afterGraceFraction} +verändert werden. Das nächste Beispiel zeigt, wie sich +der Abstand verändert, wenn der Wert 3/4, 15/16 und 1/2 der +Hauptnote beträgt. + +@lilypond[quote,verbatim,relative=2] +<< + \new Staff { + c1 \afterGrace d1 { c16[ d] } c1 + } + \new Staff { + #(define afterGraceFraction (cons 15 16)) + c1 \afterGrace d1 { c16[ d] } c1 + } + \new Staff { + #(define afterGraceFraction (cons 1 2)) + c1 \afterGrace d1 { c16[ d] } c1 + } +>> +@end lilypond + +Der Abstand zwischen der Hauptnote und der Verzierung kann auch +mit unsichtbaren Noten beeinflusst werden. Im nächsten Beispiel +wird die Verzierung mit einem Abstand von 7/8 zur Hauptnote +gesetzt. + +@lilypond[quote,verbatim,relative=2] +\new Voice { + << { d1^\trill_( } + { s2 s4. \grace { c16[ d] } } >> + c1) +} +@end lilypond + +@cindex Veränderung von Verzierungsnoten +@cindex Verzierungen verändern +@cindex Verzierungen, Aussehen verändern + +Ein @code{\grace}-Notenabschnitt wird nach besonderen Satzregeln +gesetzt, um z. B. kleinere Noten zu benutzen und die Richtung der +Hälse einzustellen. Veränderungen am Layout müssen also innerhalb +des Verzierungsausdrucks gesetzt werden, damit sie auch eine Auswirkung haben. Die Veränderungen müssen auch innerhalb des +Verzierungsausdrucks rückgängig gemacht werden. In diesem +Fall wird die Richtung der Hälse geändert und dann wieder der +Standard eingestellt: + +@lilypond[quote,verbatim,relative=2] +\new Voice { + \acciaccatura { + \stemDown + f16-> + \stemNeutral + } + g4 e c2 +} +@end lilypond + +@cindex Hals, mit Schrägstrich +@cindex durchgestrichener Hals +@cindex Notenhals, durchgestrichen + + +@snippets + +@lilypondfile[verbatim,lilyquote,texidoc,doctitle] +{using-grace-note-slashes-with-normal-heads.ly} + +@lilypondfile[verbatim,lilyquote,texidoc,doctitle] +{tweaking-grace-layout-within-music.ly} + +@lilypondfile[verbatim,lilyquote,texidoc,doctitle] +{redefining-grace-note-global-defaults.ly} + +@lilypondfile[verbatim,lilyquote,texidoc,doctitle] +{positioning-grace-notes-with-floating-space.ly} + + + +@seealso +Glossar: +@rglos{grace notes}, +@rglos{acciaccatura}, +@rglos{appoggiatura}. + +Notationsreferenz: +@ref{Manuelle Balken}. + +Installierte Dateien: +@file{ly/grace-init.ly}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{GraceMusic}, +@rinternals{Grace_beam_engraver}, +@rinternals{Grace_engraver}, +@rinternals{Grace_spacing_engraver}. + + +@knownissues + +@cindex Vorschlag, mehrere Noten +@cindex mehrnotiger Vorschlag +@cindex Synchronisation von Verzierungen +@cindex Verzierungen, Synchronisation + +Ein Vorschlag (@emph{acciaccatura}) mit mehreren Noten und +Balken wird ohne den Schrägstrich gesetzt und sieht einem +Vorhalt (@emph{appoggiatura}) sehr ähnlich. + +@c TODO Add link to LSR snippet to add slash when available + +Die Synchronisation von Verzierungen kann auch zu Überraschungen führen. +Auch andere Symbole der Systeme, wie Vorzeichen, Taktlinien usw., werden +synchronisiert. Vorsicht ist geboten, wenn nur in bestimmten Systemen +Verzierungen vorkommen: + +@lilypond[quote,relative=2,verbatim] +<< + \new Staff { e4 \bar "|:" \grace c16 d2. } + \new Staff { c4 \bar "|:" d2. } +>> +@end lilypond + +@noindent +Dem kann abgeholfen werden, indem unsichtbare Verzierungsnoten der selben +Länge in die anderen Systeme gesetzt werden. Im obigen Beispiel müsste +also + +@lilypond[quote,ragged-right,relative=2,verbatim,fragment] +<< + \new Staff { e4 \bar "|:" \grace c16 d2. } + \new Staff { c4 \bar "|:" \grace s16 d2. } +>> +@end lilypond + +@noindent +gesetzt werden. + +Der Einsatz von Verzierungsnoten innerhalb von Stimmen-Kontexten +kann den Notensatz der Stimme verwirren. Dieses Problem kann +umgangen werden, indem man eine Note oder Pause zwischen dem +@code{Voice}-Befehl und der Verzierungsnote setzt. + +@lilypond[quote,verbatim] +accMusic = { + \acciaccatura { f8 } e8 r8 \acciaccatura { f8 } e8 r4 +} + +\new Staff { + << + \new Voice { + \relative c'' { + r8 r8 \voiceOne \accMusic \oneVoice r8 | + r8 \voiceOne r8 \accMusic \oneVoice r8 | + } + } + \new Voice { + \relative c' { + s8 s8 \voiceTwo \accMusic \oneVoice s8 | + s8 \voiceTwo r8 \accMusic \oneVoice s8 | + } + } + >> +} +@end lilypond + +Verzierungsabschnitte sollten nur innerhalb von sequentiellen musikalischen +Ausdrücken benützt werden. Wenn sie ineinandergeschachtelt werden, kann es +zu Fehlermeldungen oder Abstürzen kommen. + + +@node An Kadenzen ausrichten +@unnumberedsubsubsec An Kadenzen ausrichten +@translationof Aligning to cadenzas + +@cindex Kadenz, Ausrichten an +@cindex Ausrichten an Kadenz + +In Orchesterpartituren stellen Kadenzen ein besonderes Problem dar: +Wenn in der Partitur ein Instrument eine Kadenz spielt, die notiert +wird, müssen die anderen Stimmen genau die entsprechende Anzahl Noten +überspringen, damit sie nicht zu früh oder zu spät einsetzen. + +Eine Lösung ist es, die Funktionen @code{mmrest-of-length} oder +@code{skip-of-length} zu benutzen. Diese Scheme-Funktionen +brauchen einen definierten Notenabschnitt (eine Variable) +als Argument und produzieren entweder Ganztaktpausen oder leere +Takte, die genauso lang sind wie der Notenabschnitt. + +@lilypond[verbatim,quote] +MyCadenza = \relative c' { + c4 d8 e f g g4 + f2 g4 g +} + +\new GrandStaff << + \new Staff { + \MyCadenza c'1 + \MyCadenza c'1 + } + \new Staff { + #(ly:export (mmrest-of-length MyCadenza)) + c'1 + #(ly:export (skip-of-length MyCadenza)) + c'1 + } +>> +@end lilypond + +@seealso +Glossar: +@rglos{cadenza}. + +Schnipsel: +@rlsr{Rhythms}. + + + +@node Verwaltung der Zeiteinheiten +@unnumberedsubsubsec Verwaltung der Zeiteinheiten +@translationof Time administration + +@cindex Verwaltung der Zeiteinheiten +@cindex Zeit (in der Partitur) +@cindex Noten ohne Takt +@cindex Takt, Noten ohne +@cindex Noten ohne Metrum +@cindex Metrum, Noten ohne + +@funindex currentBarNumber +@funindex measurePosition +@funindex measureLength + +Die Zeit in einer Partitur wird vom @code{Timing_translator} +verwaltet, der sich in den Standardeinstellungen im @code{Score}-Kontext +befindet. Eine Parallelbezeichnung, @code{Timing}, wird +dem Kontext hinzugefügt, in dem sich @code{Timing_translator} +befindet. Um sicherzugehen, dass @code{Timing} erhältlich ist, +muss man eventuell den enthaltenden Kontext manuell erstellen +(also etwa einen @code{Voice}- oder @code{Staff}-Kontext. + +Die folgenden Eigenschaften von @code{Timing} werden eingesetzt, +um die Zeit in Partituren zu verwalten. + +@cindex Taktnummer + +@table @code +@item currentBarNumber (aktuelle Taktnummer) +Die gerade aktuelle Taktzahl. Für ein Beispiel, das die Benutzung +dieser Eigenschaft zeigt, siehe @ref{Taktzahlen}. + +@item measureLength (Taktlänge) +Die Länge der Takte mit der aktuellen Taktart. In einem 4/4-Takt +ist sie 1, in einem 6/8-Takt 3/4. Dieser Wert bestimmt, wann +eine Taktlinie gezogen wird und wie automatische Balken erstellt +werden sollen. + +@item measurePosition (Taktposition) +Der Schlag im Takt zum aktuellen Moment. Dieser Wert wird +zurückgesetzt, indem @code{measureLength} (die Taktlänge) abgezogen +wird, wenn der Wert von @code{measureLength} erreicht oder +überschritten wird. Wenn das passiert, wird der Zähler +@code{currentBarNumber} (aktuelle Taktnummer) erhöht. + +@item timing (Zeitberechnung) +Wenn auf wahr gesetzt, werden die oben genannten Variablen +zu jedem Zeitpunkt aktualisiert. Wenn auf falsch gesetzt, +bleibt der Engraver unendlich lange im aktuellen Takt. + +@end table + +Zeitverwaltung kann geändert werden, indem man diese Variablen +direkt beeinflusst. Im nächsten Beispiel wird die normale +Taktart mit 4/4 angegeben, aber @code{measureLength} wird +auf 5/4 gesetzt. An der Stelle 4/8 des dritten Taktes wird die +Taktposition (@code{measurePosition}) um 1/8 auf 5/8 erhöht, so +dass der Takt im Ergebnis 1/8 kürzer ist. Die nächste Taktlinie +wird dann auch bei 9/8 gezogen und nicht bei 5/4. + +@lilypond[quote,verbatim,relative=1] +\set Score.measureLength = #(ly:make-moment 5 4) +c1 c4 +c1 c4 +c4 c4 +\set Score.measurePosition = #(ly:make-moment 5 8) +b4 b4 b8 +c4 c1 +@end lilypond + +@noindent +Wie das Beispiel zeigt, erstellt @code{ly:make-moment n m} +die Dauer Zähler/Nenner einer ganzen Note. Zum Beispiel heißt +@code{ly:make-moment 1 8} die Dauer einer Achtelnote, und +@code{ly:make-moment 7 16} die Dauer von sieben Sechszehntelnoten. + + +@seealso +Notationsreferenz: +@ref{Taktzahlen}, +@ref{Musik ohne Metrum}. + +Schnipsel: +@rlsr{Rhythms}. + +Referenz der Interna: +@rinternals{Timing_translator}, +@rinternals{Score}