+Neue Textbeschriftungsbefehle können mit dem
+@code{define-markup-command}-Scheme-Makro definiert werden.
+
+@lisp
+(define-markup-command (@var{befehl-bezeichnung} @var{layout} @var{props} @var{arg1} @var{arg2} ...)
+ (@var{arg1-type?} @var{arg2-type?} ...)
+ ..Befehlkörper..)
+@end lisp
+
+Die Argumente sind:
+
+@table @var
+@item argi
+@var{i}te Befehlsargument
+@item argi-type?
+eine Eigenschaft für das @var{i}te Argument
+@item layout
+die @q{layout}-Definition
+@item props
+eine Liste an alists, in der alle aktiven Eigenschaften enthalten sind
+@end table
+
+Als einfaches Beispiel soll gezeigt werden, wie man einen
+@code{\smallcaps}-Befehl hinzufügen kann, der die Kapitälchen
+für die Schriftzeichen auswählt. Normalerweise würde man Kapitälchen
+folgendermaßen auswählen:
+
+@example
+\markup @{ \override #'(font-shape . caps) Text-in-Kapitälchen @}
+@end example
+
+@noindent
+Damit wird die Kapitälchenschriftart ausgewählt, indem die
+@code{font-shape}-Eigesnchaft auf @code{#'caps} gesetzt wird,
+während @code{Text-in-caps} interpretiert wird.
+
+Damit diese Funkion als @code{\smallcaps}-Befehl zur Verfügung
+gestellt werden kann, muss eine Funktion mit @code{define-markup-command}
+definiert werden. Der Befehl braucht ein Argument vom Typ @code{markup}.
+Darum sollte der Beginn der Funktion lauten:
+
+@example
+(define-markup-command (smallcaps layout props argument) (markup?)
+@end example
+
+@noindent
+
+Was jetzt folgt, ist der eigentliche Inhalt des Befehls: das
+@code{argument} soll als Beschriftung (markup) interpretiert werden,
+also:
+
+@example
+(interpret-markup layout @dots{} argument)
+@end example
+
+@noindent
+Diese Interpretation sollte @code{'(font-shape . caps)} zu den
+aktiven Eigenschaften hinzufügen, weshalb wir das Folgende anstelle
+der @dots{} in dem Beispiel einfügen:
+
+@example
+(cons (list '(font-shape . caps) ) props)
+@end example
+
+@noindent
+Die Variable @code{props} ist eine Liste an alists, und mit @code{cons}
+wird ihr eine zusätzliche Einstellung hinzugefügt.
+
+Man könnte sich auch vorstellen, dass ein Rezitativ einer Oper
+gesetzt werden soll, und ein Befehl wäre sehr bequem, mit dem
+man die Namen der Charaktere auf eine eigene Art darstellen könnte.
+Namen sollen in Kapitälchen gesetzt werden und etwas nach links und
+oben verschoben werden. Man kann also einen @code{\character}-Befehl
+definieren, der die nötige Verschiebung berücksichtigt und
+den neuen @code{\smallcaps}-Befehl einsetzt:
+
+@example
+#(define-markup-command (character layout props name) (string?)
+ "Print the character name in small caps, translated to the left and
+ top. Syntax: \\character #\"name\""
+ (interpret-markup layout props
+ (markup #:hspace 0 #:translate (cons -3 1) #:smallcaps name)))
+@end example
+
+Hier ist eine Komplikation, die erklärt werden muss: Text über oder
+unter dem Notensystem wird vertikal verschoben um in einem bestimmten
+Abstand von dem System und den Noten zu sein (das wird als @qq{padding}
+bezeichnet). Um sicherzugehen, dass dieser Mechanismus nicht die
+vertikale Verschiebung von @code{#:translate} annulliert, wird
+die leere Zeichenkette (@code{#:hspace 0}) vor den zu verschiebenden
+Text gesetzt. Das @code{#:hspace 0} wird jetzt also über die Noten
+gesetzt und @code{name} dann relativ zu der leeren Zeichenkette
+verschoben. Im Endeffekt wird der Text nach links oben verschoben.
+
+Das Resultat sieht folgendermaßen aus:
+
+@example
+@{
+ c''^\markup \character #"Cleopatra"
+ e'^\markup \character #"Giulio Cesare"
+@}
+@end example
+
+@lilypond[quote,ragged-right]
+#(define-markup-command (smallcaps layout props str) (string?)
+ "Print the string argument in small caps. Syntax: \\smallcaps #\"string\""
+ (interpret-markup layout props
+ (make-line-markup
+ (map (lambda (s)
+ (if (= (string-length s) 0)
+ s
+ (markup #:large (string-upcase (substring s 0 1))
+ #:translate (cons -0.6 0)
+ #:tiny (string-upcase (substring s 1)))))
+ (string-split str #\Space)))))
+
+#(define-markup-command (character layout props name) (string?)
+ "Print the character name in small caps, translated to the left and
+ top. Syntax: \\character #\"name\""
+ (interpret-markup layout props
+ (markup #:hspace 0 #:translate (cons -3 1) #:smallcaps name)))
+
+{
+ c''^\markup \character #"Cleopatra" c'' c'' c''
+ e'^\markup \character #"Giulio Cesare" e' e' e'
+}
+@end lilypond
+
+In diesen Befehlen wurden Kapitälchen eingesetzt, aber es kann
+vorkommen, dass die Schriftart keine Kapitälchen zur Verfügung
+stellt. In diesem Fall können die Kapitälchen nachempfunden
+werden, indem man Großbuchstaben setzt, deren Anfangsbuchstabe
+etwas größer gesetzt wird:
+
+@example
+#(define-markup-command (smallcaps layout props str) (string?)
+ "Print the string argument in small caps."
+ (interpret-markup layout props
+ (make-line-markup
+ (map (lambda (s)
+ (if (= (string-length s) 0)
+ s
+ (markup #:large (string-upcase (substring s 0 1))
+ #:translate (cons -0.6 0)
+ #:tiny (string-upcase (substring s 1)))))
+ (string-split str #\Space)))))
+@end example
+
+Der @code{smallcaps}-Befehl spaltet die Argumente zuerst in
+Einzelstücke auf, die von Leerzeichen getrennt sind
+(@code{(string-split str #\Space)}); für jedes Einzelstück
+wird dann eine Beschriftung aufgebaut, deren erster Buchstabe
+vergrößert wird und als Versalbuchstabe gesetzt wird
+(@code{#:large (string-upcase (substring s 0 1))}), und eine
+zweite Versalbuchstaben gesetzt werden
+(@code{#:tiny (string-upcase (substring s 1))}). Wenn
+LilyPond ein Leerzeichen zwischen Beschriftungen einer Zeile
+entdeckt, wird die zweite Beschriftung nach links verschoben
+(@code{#:translate (cons -0.6 0) ...}). Dann werden die
+Beschriftungen für jedes Einzelstück in eine Zeile gesetzt
+@code{(make-line-markup ...)}. Schließlich wird die resultierende
+Beschriftung an die @code{interpret-markup}-Funktion zusammen
+mit den Argumenten @code{layout} und @code{props} weitergereicht.
+
+Achtung: ist gibt keinen internen Befehl @code{\smallCaps}, der
+benutzt werden kann, um Text in Kapitälchen zu setzen. Siehe auch
+@ref{Text markup commands}.
+
+@knownissues
+
+Im Moment sind die möglichen Kombinationen von Argumenten (nach den
+Standardargumenten @var{layout} und @var{props}), die mit
+@code{define-markup-command} definiert werden, wie folgt
+limitiert:
+
+@table @asis
+@item (kein Argument)
+@itemx @var{list}
+@itemx @var{markup}
+@itemx @var{markup markup}
+@itemx @var{scm}
+@itemx @var{scm markup}
+@itemx @var{scm scm}
+@itemx @var{scm scm markup}
+@itemx @var{scm scm markup markup}
+@itemx @var{scm markup markup}
+@itemx @var{scm scm scm}
+@end table
+
+@noindent
+Hier stellt @var{scm} native Scheme-Datentypen dar wie
+@q{number} oder @q{string}.
+
+Es ist beispielsweise nicht möglich, einen Beschriftungsbefehl
+@code{foo} mit vier Argumenten in folgender Weise zu nutzen:
+
+@example
+#(define-markup-command (foo layout props
+ num1 str1 num2 str2)
+ (number? string? number? string?)
+ ...)
+@end example
+
+@noindent
+Wenn es folgendermaßen eingesetzt wird:
+
+@example
+\markup \foo #1 #"bar" #2 #"baz"
+@end example
+
+@cindex Scheme signature
+@cindex Signatur, Scheme
+@noindent
+beschwert sich @command{lilypond}, dass @code{foo} wegen einer ungekannten
+Scheme Signatur nicht analysiert werden kann.