diff options
Diffstat (limited to 'macros/latex/contrib/tudscr/source/tudscr-manual.dtx')
-rw-r--r-- | macros/latex/contrib/tudscr/source/tudscr-manual.dtx | 6388 |
1 files changed, 6388 insertions, 0 deletions
diff --git a/macros/latex/contrib/tudscr/source/tudscr-manual.dtx b/macros/latex/contrib/tudscr/source/tudscr-manual.dtx new file mode 100644 index 0000000000..4df997a44b --- /dev/null +++ b/macros/latex/contrib/tudscr/source/tudscr-manual.dtx @@ -0,0 +1,6388 @@ +% \CheckSum{4470} +% \iffalse meta-comment +% +% TUD-Script -- Corporate Design of Technische Universität Dresden +% ---------------------------------------------------------------------------- +% +% Copyright (C) Falk Hanisch <hanisch.latex@outlook.com>, 2012-2019 +% +% ---------------------------------------------------------------------------- +% +% This work may be distributed and/or modified under the conditions of the +% LaTeX Project Public License, version 1.3c of the license. The latest +% version of this license is in http://www.latex-project.org/lppl.txt and +% version 1.3c or later is part of all distributions of LaTeX 2005/12/01 +% or later and of this work. This work has the LPPL maintenance status +% "author-maintained". The current maintainer and author of this work +% is Falk Hanisch. +% +% ---------------------------------------------------------------------------- +% +% Dieses Werk darf nach den Bedingungen der LaTeX Project Public Lizenz +% in der Version 1.3c, verteilt und/oder verändert werden. Die aktuelle +% Version dieser Lizenz ist http://www.latex-project.org/lppl.txt und +% Version 1.3c oder später ist Teil aller Verteilungen von LaTeX 2005/12/01 +% oder später und dieses Werks. Dieses Werk hat den LPPL-Verwaltungs-Status +% "author-maintained", wird somit allein durch den Autor verwaltet. Der +% aktuelle Verwalter und Autor dieses Werkes ist Falk Hanisch. +% +% ---------------------------------------------------------------------------- +% +% \fi +% +% \CharacterTable +% {Upper-case \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z +% Lower-case \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z +% Digits \0\1\2\3\4\5\6\7\8\9 +% Exclamation \! Double quote \" Hash (number) \# +% Dollar \$ Percent \% Ampersand \& +% Acute accent \' Left paren \( Right paren \) +% Asterisk \* Plus \+ Comma \, +% Minus \- Point \. Solidus \/ +% Colon \: Semicolon \; Less than \< +% Equals \= Greater than \> Question mark \? +% Commercial at \@ Left bracket \[ Backslash \\ +% Right bracket \] Circumflex \^ Underscore \_ +% Grave accent \` Left brace \{ Vertical bar \| +% Right brace \} Tilde \~} +% +% \iffalse +%%% From File: tudscr-manual.dtx +%<*dtx> +% \fi +% +\ifx\ProvidesFile\undefined\def\ProvidesFile#1[#2]{}\fi +\ProvidesFile{tudscr-manual.dtx}[2019/08/20 v2.06c TUD-Script\space% +% +% \iffalse +%</dtx> +%<package&identify>\ProvidesPackage{tudscrtutorial}[% +%<*package&identify> +%!TUD@Version +%</package&identify> +%<package&identify> package +%<*dtx|package&identify> +% \fi + (internal tutorials)% +] +% \iffalse +%</dtx|package&identify> +%<*dtx> +\documentclass[english,ngerman,xindy]{tudscrdoc} +\ifpdftex{ + \usepackage[T1]{fontenc} + \usepackage[ngerman=ngerman-x-latest]{hyphsubst} +}{ + \usepackage{fontspec} +} +\usepackage{babel} +\usepackage{tudscrfonts} +\KOMAoptions{parskip=half-} +\usepackage{bookmark} +\usepackage[babel]{microtype} + +\CodelineIndex +\RecordChanges +\GetFileInfo{tudscr-manual.dtx} +\title{\file{\filename}} +\author{Falk Hanisch\qquad\expandafter\mailto\expandafter{\tudscrmail}} +\date{\fileversion\nobreakspace(\filedate)} + +\begin{document} + \maketitle + \tableofcontents + \DocInput{\filename} +\end{document} +%</dtx> +% \fi +% +% \selectlanguage{ngerman} +% +% \changes{v2.02}{2014/12/17}{Erstellung der \app{texindy}-Stildatei während +% der Kompilierung}^^A +% \changes{v2.02}{2014/11/18}{\pkg{tudscrtutorial}: Index für Tutorials}^^A +% \changes{v2.05}{2015/08/04}{Geteilte Deklarationen für Klasse und Paket}^^A +% +% \section{Handbuch und Leitfäden zu \TUDScript} +% +% Es werden die Klasse \cls{tudscrmanual} für das Handuch sowie das Paket +% \pkg{tudscrtutorial} für das Setzen von einigen Anwenderleitfäden bzw. +% Tutorials erzeugt. Da es zwischen der Klasse und dem Paket es eine große +% Menge an Überschneidungen gibt, basieren diese auf der gleichen Quelldatei. +% Einiges davon wird auch für die Quelltextdokumentationsklasse \cls{tudscrdoc} +% verwendet. +% +% \StopEventually{\PrintIndex\PrintChanges\PrintToDos} +% +% \iffalse +%<*body|class&doc> +% \fi +% +% \subsection{Notwendige Pakete und Befehle} +% +% Basis für die Handbuchklasse \cls{tudscrmanual} ist \cls{tudscrreprt}. +% Zusätzlich wird das Paket \pkg{tudscrtutorial} erstellt, um an das Handbuch +% angelehnte Tutorials in einem Unterordner zu erstellen. Sowohl für die Klasse +% als auch das Paket werden einige Pakete geladen, um Einstellungen vorzunehmen +% und nützliche Befehle zu definieren. +% +% Das Paket \pkg{xparse} erlaubt eine sehr freie Deklaration von Makros mit +% nahezu beliebig arrangierbaren (optionalen) Argumenten. +% \begin{macrocode} +%<*!doc> +\PassOptionsToPackage{log-declarations=false}{xparse} +\RequirePackage{xparse}[2013/12/31] +%</!doc> +% \end{macrocode} +% Bugfixes für unterschiedliche Pakete. +% \begin{macrocode} +\RequirePackage{scrhack}[2014/02/27] +% \end{macrocode} +% Die Sprachunterstützung für Klasse und Paket. +% \begin{macrocode} +%<*!doc> +\RequirePackage{babel}[2014/03/24] +%</!doc> +% \end{macrocode} +% Das Paket \pkg{marginnote} stellt nicht fließenden Randnotizen bereit, welche +% für die Kennzeichnung von Änderungen, Hinweise oder ToDo-Notizen verwendet +% werden. Die Randnotizen werden auf dem linken~-- weil größeren~-- Seitenrand +% gesetzt. +% \begin{macrocode} +\PassOptionsToPackage{quiet}{marginnote} +\RequirePackage{marginnote}[2012/03/29] +%<!doc>\reversemarginpar +% \end{macrocode} +% Das Paket für intelligente Leerzeichen am Ende von Makros mit \cs{xspace}. +% \begin{macrocode} +\RequirePackage{xspace}[2009/10/20] +\xspaceaddexceptions{"=} +% \end{macrocode} +% Für das Paket \pkg{geometry} erfolgen durch \TUDScript vielerlei Anpassungen. +% Um bei einer signifikanten Änderung des Paketes passend reagieren zu können, +% wird auf das aktuelle Paketdatum geprüft und für neue Versionen eine Warnung +% erzeugt. +% \ToDo{Kann raus, sobald \pkg{geometry} nicht mehr notwendig}[v2.07] +% \begin{macrocode} +%<*!(doc|package)> +\@ifpackagelater{geometry}{2018/04/17}{% + \ClassWarning{\TUD@Class@Name}{% + Package `geometry' was updated so some patches\MessageBreak% + are maybe outdated% + }% +}{}% +%</!(doc|package)> +% \end{macrocode} +% \begin{macro}{\vTUDScript} +% \begin{macro}{\vKOMAScript} +% Diese Befehle geben in der Dokumentation die aktuelle Version von \TUDScript +% sowie die mindestens notwendige Version von \KOMAScript{} aus. +% \begin{macrocode} +\newcommand*\vTUDScript{v\TUDScriptVersionNumber} +\newcommand*\vKOMAScript{v\TUD@Version@KOMA} +% \end{macrocode} +% \end{macro}^^A \vKOMAScript +% \end{macro}^^A \vTUDScript +% \begin{macro}{\tud@english} +% Mit diesem Befehl wird der Inhalt des Arumentes mit englischen Trennmustern +% gesetzt, falls die Sprache geladen wurde. +% \begin{macrocode} +\newcommand*\tud@english[1]{#1} +\AtBeginDocument{% + \iflanguageloaded{english}{% + \renewcommand*\tud@english[1]{\foreignlanguage{english}{#1}}% + }{}% +} +% \end{macrocode} +% \end{macro}^^A \tud@english +% Das Paket \pkg{shellesc} ermöglicht mit dem Befehl \cs{ShellEscape} die +% Verwendung von Systembefehlen auf der Kommandozeile unabhängig von der +% genutzten Engine. Sollte \app{lualatex} als Dokumentprozessor eingesetzt +% werden, sind dennoch die \app{pdflatex}-Primitiven \cs{pdf(@)strcmp} und +% \cs{pdf(@)shellescape} nötig, wofür das Paket \pkg{pdftexcmds} geladen wird. +% \begin{macrocode} +\RequirePackage{shellesc}[2016/06/07] +\RequirePackage{pdftexcmds}[2016/05/21] +% \end{macrocode} +% +% \iffalse +%</body|class&doc> +%<*!doc> +%<*body> +%<*class> +% \fi +% +% \begin{macro}{\tud@list@sort} +% \changes{v2.02}{2014/07/25}{neu}^^A +% \begin{macro}{\tud@list@@sort} +% \changes{v2.02}{2014/07/25}{neu}^^A +% \begin{macro}{\tud@templist} +% \changes{v2.02}{2014/07/25}{neu}^^A +% \begin{macro}{\if@tud@list@sorted} +% \changes{v2.02}{2014/07/25}{neu}^^A +% Der Befehl \cs{tud@list@sort} erwartet eine \pkg{etoolbox}-Liste und sortiert +% diese mit dem Makro \cs{sort@list} in alphabetischer Reihenfolge in eine +% kommagetrennte Auflistung. Diese wird anschließend wieder in eine +% \pkg{etoolbox}-Liste umgewandelt. +% \begin{macrocode} +\newcommand*\tud@templist{} +\let\tud@templist\relax +\newcommand*\tud@list@sort[1]{% + \ifdefvoid{#1}{% + \ClassWarning{tudscrmanual}{% + The given list \string#1\space\MessageBreak% + is empty, nothing to sort here% + }% + }{% + \let\tud@reserved#1% + \let\tud@templist\relax% + \forlistloop\tud@list@@sort{\tud@reserved}% + \let\tud@reserved\relax% + \@for\@tempa:=\tud@templist\do{\listeadd\tud@reserved{\@tempa}}% + \let#1\tud@reserved% + }% +} +% \end{macrocode} +% Hier erfolgt die eigentliche Sortierung der Liste. +% \begin{macrocode} +\newif\if@tud@list@sorted +\newcommand*\tud@list@@sort[1]{% +% \end{macrocode} +% Der erste Eintrag wird direkt der Liste hinzugefügt. +% \begin{macrocode} + \ifx\tud@templist\relax% + \def\tud@templist{#1}% +% \end{macrocode} +% Weitere Einräge werden mit \cs{pdfstrcmp} an der richtigen Stelle eingefügt. +% Dabei wird die kommagetrennte Liste \cs{tud@templist} durchlaufen und +% \cs{@tempb} als Hilfsmakro verwendet, in welches die aktuelle Liste innerhalb +% der \cs{@for}-Schleife stückweise expandiert wird. Wenn das aktuelle Element +% an der dafür passenden Stelle eingesetzt wurde, wird \cs{if@tud@list@sorted} +% gesetzt. +% \begin{macrocode} + \else% + \@tud@list@sortedfalse% + \let\@tempb\@empty% + \@for\@tempa:=\tud@templist\do{% +% \end{macrocode} +% Ist der Eintrag bereits erfolgt, wird der verbliebene Teil der Liste +% angehangen. +% \ToDo{\cs{expandafter}\cs{edef}\cs{expandafter} ist quatsch, oder?}[v2.07] +% \begin{macrocode} + \if@tud@list@sorted% + \expandafter\edef\expandafter\@tempb\expandafter{\@tempb,\@tempa}% + \else% +% \end{macrocode} +% Liegt der Eintrag in alphabetischer Reihenfolge vor dem aktuellen der +% durchlaufenenen Liste, so wird dieser davor eingefügt. Dabei muss der Fall, +% dass das Element der erste Eintrag in der temporären Liste \cs{@tempb} ist, +% eine Sonderbehandlung erfolgen. Anschließend wird \cs{@tud@list@sortedtrue} +% gesetzt. +% \begin{macrocode} + \expandafter\ifnum\pdf@strcmp{#1}{\@tempa}<\z@\relax% + \ifx\@tempb\@empty% + \expandafter\edef\expandafter\@tempb\expandafter{% + #1,\@tempa% + }% + \else% + \expandafter\edef\expandafter\@tempb\expandafter{% + \@tempb,#1,\@tempa% + }% + \fi% + \@tud@list@sortedtrue% + \else% +% \end{macrocode} +% Ist Eintrag in alphabetischer Reihenfolge nach dem aktuellen der geprüften +% Liste, so wird dieser (noch) nicht eingefügt. Der Sonderfall des ersten +% Elementes wird abgedeckt. +% \begin{macrocode} + \ifx\@tempb\@empty% + \expandafter\edef\expandafter\@tempb\expandafter{\@tempa}% + \else% + \expandafter\edef\expandafter\@tempb\expandafter{\@tempb,\@tempa}% + \fi% + \fi% + \fi% + }% +% \end{macrocode} +% Wurde der Eintrag nach dem Durchlaufen der Liste nicht eingefügt, so erfolgt +% dies hier am Ende der Liste. +% \begin{macrocode} + \if@tud@list@sorted\else% + \expandafter\edef\expandafter\@tempb\expandafter{\@tempb,#1}% + \fi% +% \end{macrocode} +% Die temporäre Liste \cs{@tempb} wird auf \cs{tud@templist} überschrieben. +% \begin{macrocode} + \let\tud@templist\@tempb% + \fi% +} +% \end{macrocode} +% \end{macro}^^A \if@tud@list@sorted +% \end{macro}^^A \tud@templist +% \end{macro}^^A \tud@list@@sort +% \end{macro}^^A \tud@list@sort +% +% \iffalse +%</class> +%<*package> +% \fi +% +% \subsection{Zusätzliche Pakete für das Paket \pkg{tudscrtutorial}} +% +% Mit dem Paket \pkg{scrwfile} lassen sich Probleme mit zu wenig verfügbaren +% Streams für das Schreiben externer Datein beheben. Hintergrund ist die +% Verwendung des Paketes \pkg{glossaries} in einem der Tutorials, welches eine +% Vielzahl solcher Streams benötigt. Das Paket \pkg{morewrites} hat keinen +% Einfluss auf \pkg{glossaries}. +% \begin{macrocode} +\RequirePackage{scrwfile}[2013/08/05] +% \end{macrocode} +% Die Umgebungen \env{Preamble}, \env{Trunk} und \env{Hint} sowie deren +% Varianten nutzen das Paket \pkg{filecontents}, um ihren Inhalt in eine +% temporäre Datei zu schreiben und diese direkt mit dem Paket \pkg{listings} +% darzustellen sowie ggf. den Quelltext auszuführen. Beim Überschreiben einer +% Datei wird für gewöhnlich eine Warnung erzeugt. Dies wird mit dem Patch +% unterbunden. +% \begin{macrocode} +\RequirePackage{filecontents}[2011/10/08] +\begingroup% + \catcode`\*=11% + \catcode`\^^M\active% + \catcode`\^^L\active\let^^L\relax% + \catcode`\^^I\active% + \patchcmd{\filec@ntents}{% + \@latex@warning@no@line{Overwriting file `\@currdir#1'}% + }{}{}{\tud@patch@wrn{filec@tents}}% + \global\let\filec@ntents\filec@ntents% +\endgroup% +% \end{macrocode} +% +% \iffalse +%</package> +%</body> +%<*option> +% \fi +% +% \subsection{% +% Optionen für die Ausgabe von \cls{tudscrmanual} und \pkg{tudscrtutorial}% +% } +% +% \begin{option}{final} +% \begin{option}{print} +% \begin{macro}{\tudfinalflag} +% \begin{macro}{\tudprintflag} +% Diese beiden Optionen dienen zur finalen und/oder der unbunten Ausgabe. +% \begin{macrocode} +\TUD@key{final}[true]{% + \TUD@set@ifkey{final}{@tempswa}{#1}% + \ifx\FamilyKeyState\FamilyKeyStateProcessed% + \if@tempswa% + \let\tudfinalflag\relax% + \fi% + \fi% +} +\TUD@key{print}[true]{% + \TUD@set@ifkey{print}{@tempswa}{#1}% + \ifx\FamilyKeyState\FamilyKeyStateProcessed% + \if@tempswa% + \let\tudprintflag\relax% + \fi% + \fi% +} +% \end{macrocode} +% Wurde eine oder beide der Optionen \opt{final} oder \opt{print} gesetzt bzw. +% vor einem externen \app{pdflatex}-Aufruf die Flags \cs{tudfinalflag} und/oder +% \cs{tudprintflag} definiert, werden die entsprechenden Einstellungen zur +% finalen Ausgabe und/oder unbunten Druck vorgenommen und anschließend die +% entsprechenden Optionen unschädlich gemacht. +% \begin{macrocode} +\AtEndPreamble{% + \ifdef{\tudfinalflag}{% + \TUDoptions{ToDo=false}% + \TUD@key{ToDo}{\FamilyKeyStateProcessed}% + }{% + \KOMAoptions{overfullrule}% + }% + \ifdef{\tudprintflag}{% + \ifnum\tud@cd@num>\z@\relax% + \TUDoptions{cd=true}% + \fi% + \TUD@key{cd}{\FamilyKeyStateProcessed}% + \ifundef{\hypersetup}{}{\hypersetup{hidelinks}}% + }{}% +} +% \end{macrocode} +% \end{macro}^^A \tudprintflag +% \end{macro}^^A \tudfinalflag +% \end{option}^^A print +% \end{option}^^A final +% +% \iffalse +%<*class> +% \fi +% +% \subsection{Standardoptionen der Klasse \cls{tudscrmanual}} +% +% Es werden einige Optionen für das Handbuch standardmäßig aktiviert. Dazu +% werden diese an die entsprechende Elternklasse übergeben. +% \begin{macrocode} +\PassOptionsToClass{% + cdfoot=true,% + chapterpage=true,% + chapterprefix=true,% + headings=optiontoheadandtoc,% + captions=tableheading,% + numbers=noenddot,% + cd=color,% +}{\TUD@Class@Parent} +\PassOptionsToPackage{automark}{scrlayer-scrpage} +% \end{macrocode} +% +% \iffalse +%</class> +%</option> +%<*body> +%<*class> +% \fi +% +% \subsection{Debug-Traces für die Klasse \cls{tudscrmanual}} +% +% Ab und an ist es beim Erstellen des Handbuchs recht sinnvoll, verschiedene +% Dinge direkt im Logfile zu überprüfen. Hierfür werden folgend einige Befehle +% zur Ablaufkontrolle definiert. +% +% \begin{macro}{\tracinglabels} +% \changes{v2.05}{2015/10/29}{neu}^^A +% \begin{macro}{\tud@trace@lbl@created@add} +% \changes{v2.05}{2015/10/29}{neu}^^A +% \begin{macro}{\tud@trace@lbl@missing@add} +% \changes{v2.05}{2015/10/29}{neu}^^A +% \begin{macro}{\tud@trace@lbl@created@list} +% \changes{v2.05}{2015/10/29}{neu}^^A +% \begin{macro}{\tud@trace@lbl@missing@list} +% \changes{v2.05}{2015/10/29}{neu}^^A +% Mit \cs{tracinglabels} wird die Nachverfolgung aller erstellten Labels in der +% Dokumentation aktiviert werden. Die Label werden zum einen direkt im Logfile +% ausgegeben und am Ende des selbigen in einer sortierten Liste ausgegeben. Die +% Sternversion des Befehls erzeugt keine sortierte Liste. Über das optionale +% Argument kann mit verschiedenen Schlüsseln zudem eingestellt werden, ob alle +% Label (\val{all}) oder nur die erstellten (\val{created}) beziehungsweise die +% fehlenden (\val{missing}) nachverfolgt werden sollen. +% \begin{macrocode} +\newcommand*\tud@trace@lbl@created@add[1]{} +\newcommand*\tud@trace@lbl@missing@add[1]{} +\NewDocumentCommand\tracinglabels{!s !O{missing}}{% + \newcommand*\tud@trace@lbl@created@list{}% + \newcommand*\tud@trace@lbl@missing@list{}% + \@tempswafalse% + \ifstr{#2}{created}{\@tempswatrue}{}% + \ifstr{#2}{all}{\@tempswatrue}{}% + \if@tempswa% + \renewcommand*\tud@trace@lbl@created@add[1]{% + \typeout{% + +++++ label created: ##1 on page \thepage% + }% + \xifinlist{##1}{\tud@trace@lbl@created@list}{}{% + \listxadd\tud@trace@lbl@created@list{##1}% + }% + }% + \IfBooleanF{#1}{% + \AfterEndDocument{% + \typeout{+++++ labels created (sorted) +++++}% + \tud@list@sort\tud@trace@lbl@created@list% + \forlistloop\typeout{\tud@trace@lbl@created@list}% + }% + }% + \fi% + \@tempswafalse% + \ifstr{#2}{missing}{\@tempswatrue}{}% + \ifstr{#2}{all}{\@tempswatrue}{}% + \if@tempswa% + \renewcommand*\tud@trace@lbl@missing@add[1]{% + \typeout{% + +++++ label missing: ##1 on page \thepage% + }% + \xifinlist{##1}{\tud@trace@lbl@missing@list}{}{% + \listxadd\tud@trace@lbl@missing@list{##1}% + }% + }% + \IfBooleanF{#1}{% + \AfterEndDocument{% + \typeout{+++++ labels missing (sorted) +++++}% + \tud@list@sort\tud@trace@lbl@missing@list% + \forlistloop\typeout{\tud@trace@lbl@missing@list}% + }% + }% + \fi% +} +\@onlypreamble\tracinglabels +% \end{macrocode} +% \end{macro}^^A \tud@trace@lbl@missing@list +% \end{macro}^^A \tud@trace@lbl@created@list +% \end{macro}^^A \tud@trace@lbl@missing@add +% \end{macro}^^A \tud@trace@lbl@created@add +% \end{macro}^^A \tracinglabels +% \begin{macro}{\tracingmarkup} +% \changes{v2.05}{2015/10/29}{neu}^^A +% \begin{macro}{\tud@trace@markup} +% \changes{v2.05}{2015/10/29}{neu}^^A +% Mit \cs{tracinglabels} wird die Nachverfolgung aller Aufrufe von +% \cs{Process@@MarkupDeclare} und \cs{Process@@MarkupInline} durch +% \cs{Process@Markup} inklusive all ihrer Argumente aktiviert. Dies ist für die +% Kontrolle des erzeugten Markups sinnvoll. +% \begin{macrocode} +\newcommand*\tud@trace@markup[2]{} +\newcommand*\tracingmarkup{% + \renewcommand*\tud@trace@markup[2]{% + \typeout{+++++ markup ##1 on page \thepage^^J##2}% + }% +} +\@onlypreamble\tracingmarkup +% \end{macrocode} +% \end{macro}^^A \tud@trace@markup +% \end{macro}^^A \tracingmarkup +% \begin{macro}{\tracingbundle} +% \changes{v2.05}{2015/10/29}{neu}^^A +% \begin{macro}{\tud@trace@bdl@add} +% \changes{v2.05}{2015/10/29}{neu}^^A +% \begin{macro}{\tud@trace@bdl@list} +% \changes{v2.05}{2015/10/29}{neu}^^A +% Wird \cs{tracingbundle} in der Präambel verwendet, werden alle direkt oder +% indirekt durch \cs{Process@Markup} im Handbuch erzeugten Querverweise auf +% Klassen oder Pakete aus dem \TUDScript-Bundle nachverfolgt und am Ende des +% Logfiles ausgegeben. Damit kann im Zweifel übeprüft werden, ob eventuell eine +% falsche Referenz genutzt wurde, wodurch u.\,U. Querverweise oder Einträge in +% Index und Änderungsliste fehlerhaft werden oder erst gar nicht erscheinen. +% \begin{macrocode} +\newcommand*\tud@trace@bdl@add[1]{} +\newcommand*\tud@trace@bdl@list{} +\newcommand*\tracingbundle{% + \renewcommand*\tud@trace@bdl@add[1]{% + \begingroup% + \def\Class####1{class:####1}% + \def\Package####1{package:####1}% + \xifinlist{##1}{\tud@trace@bdl@list}{}{% + \listxadd\tud@trace@bdl@list{##1}% + }% + \endgroup% + }% + \AfterEndDocument{% + \typeout{+++++ bundle list +++++}% + \forlistloop\typeout{\tud@trace@bdl@list}% + }% +} +\@onlypreamble\tracingbundle +% \end{macrocode} +% \end{macro}^^A \tud@trace@bdl@list +% \end{macro}^^A \tud@trace@bfundle +% \end{macro}^^A \tracingbundle +% +% \iffalse +%</class> +%</body> +%</!doc> +%<*body|class&doc> +% \fi +% +% \subsection{Anpassungen für das Paket \pkg{hyperref} und Querverweise} +% +% Das Paket \pkg{hyperref} wird für alle möglichen Links und Querverweise +% geladen, \pkg{bookmark} verbessert das Erstellen der Outline-Einträge. +% \begin{macrocode} +\PassOptionsToPackage{hyperindex=false,colorlinks,linkcolor=blue}{hyperref} +\PassOptionsToPackage{open,openlevel=0}{bookmark} +% \end{macrocode} +% Es folgen einige Befehle, die an das Paket \pkg{hyperref} gekoppelt sind. +% Sobald das Paket geladen wurde, werden die Makros mit der jeweiligen +% Funktionalität definiert. +% \begin{macrocode} +\AfterPackage*{hyperref}{% +% \end{macrocode} +% Zuerst die Einstellungen für \cls{tudscrmanual} und \pkg{tudscrtutorial}. +% +% \iffalse +%<*!doc> +% \fi +% +% Die Bezeichner für die Abschnittsebenen werden umbenannt. +% \begin{macrocode} + \renewcaptionname{ngerman}{\sectionautorefname}{Unterkapitel}% + \renewcaptionname{ngerman}{\subsectionautorefname}{Abschnitt}% + \renewcaptionname{ngerman}{\subsubsectionautorefname}{Unterabschnitt}% +% \end{macrocode} +% \begin{macro}{\tudhyperdef} +% \changes{v2.02}{2014/10/27}{neu}^^A +% \begin{macro}{\tudhyperref} +% \changes{v2.02}{2014/10/27}{neu}^^A +% \begin{macro}{\tud@manualname} +% \changes{v2.05}{2015/1q/19}{neu}^^A +% Diese Befehle dienen sowohl zum Definieren von Textankern im Handbuch als +% auch zum Referenzieren auf diese. Bei der Erstellung des Ankers mit +% \cs{tudhyperdef} wird zusätzlich auch noch ein Label (\cs{label}) erzeugt. +% Der Anker wird mit \cs{Hy@raisedlink}~-- wie es auch bei pkg{hyperref}-Labels +% geschieht~-- über die Grundlinie gehoben. Die Sternversion sollte nach +% Überschriften verwendet werden und verschiebt die vertikale Position des +% Ankers noch weiter nach oben. +% \begin{macrocode} + \newcommand*\tud@manualname{tudscr}% +%<*class> + \NewDocumentCommand\tudhyperdef{s t' m}{% + \@tempswafalse% + \IfBooleanT{#1}{\@tempswatrue\setlength\@tempdima{3\baselineskip}}% + \IfBooleanT{#2}{\@tempswatrue\setlength\@tempdima{15\baselineskip}}% + \if@tempswa% + \raisebox{\@tempdima}[0pt][0pt]{\hyperdef{\tud@manualname}{#3}{}}% + \par\nobreak\vskip\dimexpr-\parskip-\baselineskip\relax% + \@afterindentfalse\@afterheading% + \else% + \Hy@raisedlink{\hyperdef{\tud@manualname}{#3}{}}\ignorespaces% + \fi% + \label{#3}% + \tud@trace@lbl@created@add{#3}% + }% + \newcommand*\tudhyperref[2]{\hyperref{}{\tud@manualname}{#1}{#2}}% +%</class> +% \end{macrocode} +% Aus einem Tutorial erfolgen alle Querverweise mit \cs{tudhyperref} auf das +% Anwenderhandbuch \enquote*{tudscr} im übergeordneten Ordner. +% \begin{macrocode} +%<*package> + \newcommand*\tudhyperref[2]{% + \hyperref{../\tud@manualname.pdf}{\tud@manualname}{#1}{#2}% + }% +%</package> +% \end{macrocode} +% \end{macro}^^A \tud@manualname +% \end{macro}^^A \tudhyperref +% \end{macro}^^A \tudhyperdef +% \begin{macro}{\autorefname} +% \begin{macro}{\auto@refname} +% \begin{macro}{\auto@@refname} +% Der Befehl \cs{autorefname} dient dazu, den Verweistyp beziehungsweise den +% Bezeichner des aktuellen~-- oder optional eines speziellen~-- Labels ohne die +% dazugehörige Nummerierung zu erhalten. Das zugrunde liegende Funktionsprinzip +% wurde bei \hrfn{http://tex.stackexchange.com/q/33776/}{LaTeX Stack Exchange} +% vorgestellt und hier übernommen. +% \begin{macrocode} + \newcommand*\autorefname[1][current]{% + \ifstr{#1}{current}{% + \expandafter\HyPsd@@autorefname\@currentHref\@nil% + }{% + \auto@refname\HyPsd@@autorefname{#1}% + }% + \unskip\xspace% + }% + \newcommand*\auto@refname[2]{% + \expandafter\ifx\csname r@#2\endcsname\relax% + ??% + \else% + \expandafter\expandafter\expandafter\auto@@refname% + \csname r@#2\endcsname{}{}{}{}\@nil#1\@nil% + \fi% + }% + \newcommand*\auto@@refname{}% + \def\auto@@refname#1#2#3#4#5\@nil#6\@nil{#6#4.\@nil}% +% \end{macrocode} +% \end{macro}^^A \auto@@refname +% \end{macro}^^A \auto@refname +% \end{macro}^^A \autorefname +% Nun die Einstellungen für \cls{tudscrdoc}. +% +% \iffalse +%</!doc> +%<*doc> +% \fi +% +% \begin{macro}{\hypersourcedef} +% \changes{v2.05}{2016/04/26}{neu}^^A +% \begin{macro}{\hypersource@def} +% \changes{v2.05}{2016/04/26}{neu}^^A +% \begin{macro}{\hypersource@ref@codeline} +% \changes{v2.05}{2016/04/26}{neu}^^A +% \begin{macro}{\hypersource@ref@page} +% \changes{v2.05}{2016/04/26}{neu}^^A +% Diese Makros werden verwendet, um im Index respektive in der Änderungsliste +% mithilfe von \pkg{hyperref} Hyperlinks auf Codezeilen respektive Seiten im +% Dokument zu setzen. +% +% Mit \cs{hypersourcedef} wird ein Textanker gesetzt, falls dieser noch nicht +% definiert wurde, was durch \cs{hypersource@def} abgesichert wird. Als +% Argument wird hierfür die aktuelle Codezeile verwendet. +% \begin{macrocode} + \newcommand*\hypersource@def{} + \newcommand*\hypersourcedef[1]{% + \ifstr{#1}{\hypersource@def}{}{% + \Hy@raisedlink{\hyperdef{}{source:#1}{}}% + \xdef\hypersource@def{#1}% + }% + }% +% \end{macrocode} +% Mit \cs{hypersource@ref@\dots} wird auf Anker im Dokument verlinkt. Dies +% erfolgt indirekt über die Attribute \val{main} bzw. \val{usage}, welche bei +% der Definitionen von Befehlen etc. im Index genutzt werden. Hierfür werden +% die dazugehörigen Makros umdefiniert. +% \begin{macrocode} + \newcommand*\hypersource@ref@codeline[2][\@firstofone]{% + \begingroup% + \def\@tempa##1{\hyperref{}{}{source:##1}{#1{##1}}}% + \forcsvlist\@tempa{#2}% + \endgroup% + }% + \newcommand*\hypersource@ref@page[2][\@firstofone]{% + \begingroup% + \def\@tempa##1{\hyperlink{page.##1}{#1{##1}}}% + \forcsvlist\@tempa{#2}% + \endgroup% + }% + \renewcommand*\main[1]{% + \ifcodeline@index% + \hypersource@ref@codeline[\underline]{#1}% + \else% + \hypersource@ref@page[\underline]{#1}% + \fi% + }% + \renewcommand*\usage[1]{\hypersource@ref@page[\textit]{#1}}% +% \end{macrocode} +% \end{macro}^^A \hypersource@ref@page +% \end{macro}^^A \hypersource@ref@codeline +% \end{macro}^^A \hypersource@def +% \end{macro}^^A \hypersourcedef +% +% \iffalse +%</doc> +% \fi +% +% Das war's. Damit sind die Ausführungen für das Paket \pkg{hyperref} beendet. +% \begin{macrocode} +} +% \end{macrocode} +% Sollte das Paket \pkg{hyperref} nicht geladen werden, wird eine Rückfallebene +% definiert, wodurch die Klasse dennoch verwendet werden kann. +% \begin{macrocode} +\TUD@UnwindPackage{hyperref}{% +% \end{macrocode} +% Zunächst die direkt innerhalb der Dokumentation verwendeten Befehle nebst +% dazugehöriger Warnung. +% \begin{macrocode} +%<*!doc> +%<*class> + \ClassWarningNoLine{tudscrmanual}% +%</class> +%<*package> + \PackageWarningNoLine{tudscrtutorial}% +%</package> + {% + It is strongly recommended to load package `hyperref'. \MessageBreak% + Nevertheless, essential commands are rudimentarily\MessageBreak% + defined. At least the package `url' is loaded% + }% +%</!doc> +% \end{macrocode} +% \begin{macro}{\hypersetup} +% \begin{macro}{\href} +% \begin{macro}{\phantomsection} +% \begin{macro}{\texorpdfstring} +% \begin{macro}{\nolinkurl} +% Einige vom Paket \pkg{hyperref} definierten Befehle werden vorgehalten. +% \begin{macrocode} + \providecommand*\hypersetup[1]{}% + \providecommand*\href[3][]{#3}% + \providecommand*\phantomsection{}% + \providecommand*\texorpdfstring[2]{#1}% + \RequirePackage{url}[2013/09/16]% + \providecommand*\nolinkurl[1]{\url{#1}}% +% \end{macrocode} +% \end{macro}^^A \nolinkurl +% \end{macro}^^A \texorpdfstring +% \end{macro}^^A \phantomsection +% \end{macro}^^A \href +% \end{macro}^^A \hypersetup +% +% \iffalse +%<*!doc> +% \fi +% +% \begin{macro}{\hyperpage} +% \begin{macro}{\autoref} +% Der Befehl \cs{autoref} wird auch in der Sternversion genutzt. +% \begin{macrocode} + \providecommand*\hyperpage[1]{#1}% + \providecommand*\autoref{??\xspace\kernel@ifstar{\ref}{\ref}}% +% \end{macrocode} +% \end{macro}^^A \autoref +% \end{macro}^^A \hyperpage +% \begin{macro}{\hyperdef} +% \begin{macro}{\hyperref} +% \begin{macro}{\tud@hyperref@a} +% \begin{macro}{\tud@hyperref@b} +% Mit \cs{hyperdef} wird ein ein Label direkt vor dem Text eingefügt. +% \begin{macrocode} + \providecommand*\hyperdef[3]{\label{#1.#2}#3}% +% \end{macrocode} +% Der Befehl \cs{hyperref} existiert in zwei Varianten. Entweder mit einem +% optionalen und einem obligatorischen Argument oder mit vier Argumenten. +% \begin{macrocode} + \providerobustcmd*\hyperref{% + \kernel@ifnextchar[{\tud@hyperref@a}{\tud@hyperref@b}% + } + \newcommand*\tud@hyperref@a[2][]{#2} + \newcommand*\tud@hyperref@b[4]{#4} +% \end{macrocode} +% \end{macro}^^A \tud@hyperref@b +% \end{macro}^^A \tud@hyperref@a +% \end{macro}^^A \hyperref +% \end{macro}^^A \hyperdef +% \begin{macro}{\partautorefname} +% \begin{macro}{\chapterautorefname} +% \begin{macro}{\sectionautorefname} +% \begin{macro}{\subsectionautorefname} +% \begin{macro}{\subsubsectionautorefname} +% Die notwendigen, lokalen Bezeichner der Gliederungsebenen. +% \begin{macrocode} + \tud@localization@german{\partautorefname}{Teil}% + \tud@localization@german{\chapterautorefname}{Kapitel}% + \tud@localization@german{\sectionautorefname}{Unterkapitel}% + \tud@localization@german{\subsectionautorefname}{Abschnitt}% + \tud@localization@german{\subsubsectionautorefname}{Unterabschnitt}% + \tud@localization@english{\partautorefname}{Part}% + \tud@localization@english{\chapterautorefname}{chapter}% + \tud@localization@english{\sectionautorefname}{section}% + \tud@localization@english{\subsectionautorefname}{subsection}% + \tud@localization@english{\subsubsectionautorefname}{subsubsection}% +% \end{macrocode} +% \end{macro}^^A \subsubsectionautorefname +% \end{macro}^^A \subsectionautorefname +% \end{macro}^^A \sectionautorefname +% \end{macro}^^A \chapterautorefname +% \end{macro}^^A \partautorefname +% Anschließend folgen die für Anwenderdokumentation eigens definierten Befehle. +% \begin{macrocode} +%<*class> + \ProvideDocumentCommand\tudhyperdef{st'm}{\label{#3}}% +%</class> + \providecommand*\tudhyperref[2]{#2}% + \providecommand*\autorefname[1][]{??\xspace}% +% +% \iffalse +%</!doc> +%<*doc> +% \fi +% +% \end{macrocode} +% Und hier der Teil für die Quelltextdokumentation. +% \begin{macrocode} + \providecommand*\hypersourcedef[1]{} + \providecommand*\hypersource@def{} + \providecommand*\hypersource@ref@codeline[2][]{} + \providecommand*\hypersource@ref@page[2][]{} +% +% \iffalse +%</doc> +% \fi +% +% \begin{macrocode} +} +% \end{macrocode} +% \begin{macro}{\hrfn} +% \changes{v2.02}{2014/08/16}{neu}^^A +% \changes{v2.04}{2015/02/18}{Schriftgröße mit \cs{scalebox}}^^A +% Mit diesem Makro können Hyperlinks im Fließtext erzeugt werden, welche +% zusätzlich noch die dazugeörige URL als Fußnote anzeigen. +% \begin{macrocode} +\newcommand*\hrfn[2]{% + \href{#1}{\trim@spaces{#2}}% + \footnote{% + \begingroup% +% \end{macrocode} +% Die Gruppe wird verwendet, um Unterstriche zu entschärfen, die im Zweifel zu +% Fehlern führen können. +% \begin{macrocode} + \def\_{_}% + \edef\@tempa{#1}% + \strut\expandafter\url\expandafter{\@tempa}% + \endgroup% + }% +} +% \end{macrocode} +% \end{macro}^^A \hrfn +% \begin{macro}{\mailto} +% Ein Makro zur Angabe einer verlinkten E"~Mail-Adresse. +% \begin{macrocode} +\newrobustcmd*\mailto[1]{\mbox{\href{mailto:#1}{\nolinkurl{#1}}}}% +% \end{macrocode} +% \end{macro}^^A \mailto +% Wenn \pkg{hyperref} geladen wird, erzeugt das Paket \pkg{babel} innerhalb von +% \cs{pdfstringdef} ziemlich viele und absolut unnötige Infos in der Form +% \texttt{Package babel Info: Redefining ngerman shorthand}. Dieser Patch dient +% zum Unterdrücken dieser Infos. +% \begin{macro}{\pdfstringdef} +% \begin{macrocode} +\AfterPackage*{hyperref}{% + \patchcmd{\pdfstringdef}{\csname HyPsd@babel@}{% + \let\bbl@info\@gobble\csname HyPsd@babel@% + }{}{\tud@patch@wrn{pdfstringdef}}% +} +% \end{macrocode} +% \end{macro}^^A \pdfstringdef +% +% \iffalse +%</body|class&doc> +%<*body> +% \fi +% +% \begin{macro}{\fullref} +% Verbesserte Referenzierungen auf Seiten. +% \begin{macrocode} +\RequirePackage{varioref}[2011/10/02] +\renewcommand*\fullref[1]{\hyperref[#1]{\autoref*{#1} \vpageref{#1}}} +% \end{macrocode} +% \end{macro}^^A \fullref +% Das Paket \pkg{microtype} wird für den optischen Randausgleich verwendet. Es +% sollte erst nach \pkg{hyperref} geladen werden. +% \begin{macrocode} +\AfterPackage*{hyperref}{\RequirePackage[babel]{microtype}[2013/05/23]} +% \end{macrocode} +% Wurde \pkg{hyperref} nicht geladen, dann soll auf \pkg{microtype} trotzdem +% nicht verzichtet werden. +% \begin{macrocode} +\TUD@UnwindPackage{hyperref}{\RequirePackage[babel]{microtype}[2013/05/23]} +% \end{macrocode} +% +% \iffalse +%</body> +%<*!doc> +%<*body> +%<*class> +% \fi +% +% \subsection{Deklarationsumgebungen für die Klasse \cls{tudscrmanual}} +% +% Die Umgebungen beiden \env{Declaration} und \env{Declaration*} sowie +% \env{Obsolete} und \env{Bundle} werden für die Beschreibung von Optionen, +% Umgebungen, Befehlen etc. verwendet, welche von \TUDScript dem Anwender zur +% Verfügung gestellt werden. +% +% \begin{macro}{\if@tud@declare} +% \begin{macro}{\if@openindex} +% \begin{macro}{\tud@declare@num} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Dies sin ein paar Hilfsmakros zur Steuerung des Markup sowie der Ausgabe von +% Deklarationen, Index und Änderungsliste, welche bei den nächsten Befehlen und +% Umgebungen genutzt werden. Mit \cs{if@tud@declare} wird festgelegt, ob die +% Befehle für das Markup in der Ausgabe als Deklaration oder anderweiteig +% erfolgt. Der Schalter \cs{if@openindex} wird zu Beginn einer Deklaration auf +% \val{true} gesetzt und vor dem Beenden auf \val{false}. Damit wird bestimmt, +% ob ein öffnender oder ein schließender Indexeintrag erzeugt werden soll. +% \begin{macrocode} +\newif\if@tud@declare +\newif\if@openindex +% \end{macrocode} +% Das Makro \cs{tud@declare@num} bestimmt innerhalb einer Deklaration, wie +% das Markup erfolgen soll. Die möglichen Werte sind bei der Beschreibung von +% \cs{Process@@MarkupDeclare} zu finden. +% \begin{macrocode} +\newcommand*\tud@declare@num{0} +% \end{macrocode} +% \end{macro}^^A \tud@declare@num +% \end{macro}^^A \if@openindex +% \end{macro}^^A \if@tud@declare +% \begin{environment}{Declaration} +% \begin{environment}{Obsolete} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\tud@declaration@list} +% \begin{macro}{\if@tud@obsolete} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Es werden einige Hilfsmakros für die Ausgabe einer Deklaration sowie der +% dazugehörigen Änderungsliste initialisiert. +% \begin{macrocode} +\newcommand*\tud@declaration@list{} +\let\tud@declaration@list\relax +% \end{macrocode} +% Die \env{Declaration}-Umgebung dient zur Deklaration von Optionen, Umgebungen, +% Befehlen, Parametern, Bezeichnern, Längen, Schriftelementen und Farben. Diese +% werden mit den entsprechenden Auszeichnungsbefehlen als obligatorisches +% Argument übergeben. Zuvor kann noch vorher im ersten optionalen Argument eine +% Beschreibung für die Änderungsliste in der Form \oarg{Verison!Beschreibung} +% angegeben werden. Danach kann im dritten Argument~-- das zweite optionale~-- +% die Voreinstellung für eine Option oder dergleichen angegeben werden. Das +% nächste optionale Argument erlaubt die Angabe einer bedingten Voreinstellung, +% also einer anderen Voreinstellung als der zuerst angegeben unter bestimmten +% Voraussetzungen. Diese wird in der Form \oarg{Bedingung:Voreinstellung} +% angegeben. Das letzte Argument ist ebenfalls optional, wird aber in der Form +% \marg{Zusatz} angegeben und enthält ggf. zusätzliche Informationen. +% +% Die Umgebung \env{Obsolete} hat eine ganz ähnliche Funktion, wird allerdings +% für die Deklaration veralteter Befehle, Umgebungen, Optionen etc. verwendet. +% Da sich beide Umgebungen stark ähneln, werden zum Start bzw. zum Abschluss +% die Makros \cs{tud@declare@start} bzw. \cs{tud@declare@end} aufgerufen. Zu +% Beginn wird nichts weiter ausgegeben sondern lediglich alle übergebenen +% Argumente in jeweiligen Listen gesammelt. Die eigentliche Ausgabe der +% Deklaration erfolgt mit dem Befehl \cs{printdeclarationlist} bezieungsweise +% \cs{printobsoletelist}. +% \begin{macrocode} +\NewDocumentEnvironment{Declaration}{omoog}{% + \listadd\tud@declaration@list{#2}% + \tud@declare@start[#1]{#2}[#3][#4]{#5}% +}{% + \tud@declare@end{#2}{\printdeclarationlist}% +} +% \end{macrocode} +% Für die Umgebung \env{Obsolete} sieht die Eingabe etwas anders aus. Das erste +% obligatorische Argument sollte eine Versionsnummer enthalten, ab wann die +% Deklaration veraltet ist. Das erste optionale Argument wird genutzt, wenn +% für eine weiterhin gültige Deklaration lediglich ein bestimmter Wert +% entfällt. Wird das erste Argument leer gelassen, erfolgt lediglich die +% Ausgabe der Deklaration ohne einen Eintrag in die Änderungsliste. Dies ist +% für Umgebungen und Befehle gedacht, bei denen lediglich ein oder mehrere +% Parameter geändert wurden bzw. entfallen. +% \begin{macrocode} +\newif\if@tud@obsolete +\NewDocumentEnvironment{Obsolete}{momoog}{% + \@tud@obsoletetrue% + \ifxblank{#1}{% +% \end{macrocode} +% Ohne Versionsnummer erfolgt die Ausgabe ohne Label. Für den Eintrag wird auch +% keine Änderungsnotiz erzeugt. +% \begin{macrocode} + \listadd\tud@declaration@list{% + \def\tud@declare@num{1}% + #3% + \def\tud@declare@num{0}% + }% + \tud@declare@start{#3}[#4][#5]{#6}% + }{% + \listadd\tud@declaration@list{#3}% +% \end{macrocode} +% Wurde ein optionales Argument angegeben, bezieht sich der Änderungseintrag +% auf ebendieses Argument, die eigentliche, obsolete Deklaration wird als +% Untereintrag genutzt. +% \begin{macrocode} + \IfValueTF{#2}{% + \Changed@At@CreateList[#2]{#1!#3}% + }{% + \Changed@At@CreateList[#3]{#1}% + }% + \IfValueTF{#6}{% + \tud@declare@start{#3}[#4][#5]{#6}% +% \end{macrocode} +% Ohne eine zusätzliche Angabe imletzten optionalen Argument wird standardmäßig +% der Entfall der Deklaration angegeben. Alternativ dazu kann im ersten +% Argument der Versionsangabe mit einem Dopppelpunkt von dieser getrennt eine +% neue bzw. aktuell gültige Deklaration als Querverweis angegeben werden. +% \begin{macrocode} + }{% + \toks@{\tud@declare@start{#3}[#4][#5]}% + \def\@tempa{\emph{entf\"allt}}% + \in@{:}{#1}% + \ifin@% + \def\@tempb##1:##2\@nil{% + \IfArgIsEmpty{##2}{}{% + \def\@tempa{\seeref{##2'page'}}% + }% + }% + \@tempb#1\@nil% + \fi% + \eaddto@hook\toks@{\expandafter{\@tempa}}% + \the\toks@% + }% + }% + \@tud@obsoletefalse% +}{% + \@tud@obsoletetrue% + \tud@declare@end{#3}{\printobsoletelist}% + \@tud@obsoletefalse% +} +% \end{macrocode} +% \end{macro}^^A \if@tud@obsolete +% \end{macro}^^A \tud@declaration@list +% \end{environment}^^A Obsolete +% \end{environment}^^A Declaration +% \begin{macro}{\tud@preset@list} +% \begin{macro}{\if@tud@preset@list} +% \begin{macro}{\tud@additional@list} +% \begin{macro}{\if@tud@additional@list} +% Dies sind die temporären listen, die für alle Deklarationen verwendet werden. +% \begin{macrocode} +\newcommand*\tud@preset@list{} +\let\tud@preset@list\relax +\newif\if@tud@preset@list +\newcommand*\tud@additional@list{} +\let\tud@additional@list\relax +\newif\if@tud@additional@list +% \end{macrocode} +% \end{macro}^^A \if@tud@additional@list +% \end{macro}^^A \tud@additional@list +% \end{macro}^^A \if@tud@preset@list +% \end{macro}^^A \tud@preset@list +% \begin{macro}{\tud@declare@start} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\tud@declare@end} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Dies sind die Makros für die eigentliche Abarbeitung der Deklarationsbefehle +% zu Beginn und Ende der Umgebungen \env{Declaration} und \env{Obsolete}. +% \begin{macrocode} +\NewDocumentCommand\tud@declare@start{omr[]r[]m}{% +% \end{macrocode} +% Die optional angegebenen Änderungen werden mit \cs{Changed@At@CreateList} in +% der Liste \cs{tud@changedat@list} gesichert und später sowohl für die +% Randnotiz als auch die Änderungsliste verarbeitet. +% \begin{macrocode} + \Changed@At@CreateList[#2]{#1}% +% \end{macrocode} +% Hier noch die Listen für Voreinstellungen\dots +% \begin{macrocode} + \IfValueTF{#3}{% + \@tud@preset@listtrue% + \def\@tempa{Voreinstellung: \PValue{#3}}% + \IfValueT{#4}{% + \def\@tempb[##1:##2]{##1: \PValue{##2}}% + \eappto\@tempa{ | \expandonce{\@tempb[#4]}}% + }% + \listeadd\tud@preset@list{\expandonce\@tempa}% + }{% + \listadd\tud@preset@list{\relax}% + }% +% \end{macrocode} +% \dots sowie zusätliche Informationen. +% \begin{macrocode} + \IfValueTF{#5}{% + \@tud@additional@listtrue% + \listadd\tud@additional@list{(#5)}% + \in@{\Environment}{#2}% + \ifin@\listadd\tud@additional@list{\tabularnewline}\fi% + }{% + \listadd\tud@additional@list{\relax}% + \in@{\Environment}{#2}% + \ifin@% + \listadd\tud@additional@list{\relax}% + \listadd\tud@additional@list{\relax}% + \fi% + }% +} +% \end{macrocode} +% Am Ende der Umgebungen wird das übergebenen Hauptargument erneut ausgeführt, +% was zum Beenden der Indexeinträge für die jeweilige Deklaration führt +% (\cs{@openindexfalse}, siehe \cs{Process@Index}). Dafür werden die Makros für +% die Angabe obligatorischer und optionaler Parameter lokal umdefiniert. +% \begin{macrocode} +\newcommand*\tud@declare@end[2]{% + \ifx\tud@declaration@list\relax\else% + \ClassError{tudscrmanual}{\string#2\space is missing}{% + \string\tud@declaration@list\space is not empty. Did you\MessageBreak% + forget to print this list with\MessageBreak% + \string#2?% + }% + \fi% + \vskip-\lastskip% + \@tud@declaretrue\@openindexfalse#1\@tud@declarefalse% + \pagebreak[1]% +} +% \end{macrocode} +% \end{macro}^^A \tud@declare@end +% \end{macro}^^A \tud@declare@start +% \begin{environment}{Declaration*} +% \changes{v2.02}{2014/10/09}{neu}^^A +% \changes{v2.05}{2015/08/04}{Indexaufteilung/-markup für Klassen und Pakete}^^A +% Die Sternversion der Umgebung \env{Declaration*} ist für die vereinfachte +% Deklaration von Klassen, Paketen etc. gedacht, bei denen keine Ausgabe +% sondern lediglich Hyperlink, Indexeintrag und Änderungsnotiz erzeugt werden +% sollen. Hierbei werden die beiden Befehle \cs{tud@declare@special@start} und +% \cs{tud@declare@special@end} genutzt, wobei der Anker des erzeugten Labels +% nicht erhöht sondern auf der aktuellen Grundlinie erzeugt wird. +% \begin{macrocode} +\NewDocumentEnvironment{Declaration*}{om}{% + \tud@declare@special@start[#1]{#2}{2}% +}{% + \tud@declare@special@end{#2}% +} +% \end{macrocode} +% \end{environment}^^A Declaration* +% \begin{environment}{Bundle*} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Die Umgebung \env{Bundle*} wird verwendet, wenn ein zusätzliches Paket oder +% eine weitere Klasse in Ergänzung zu den Hauptklassen dokumentiert wird. +% Hierfür wird die Umgebung \env{Bundle} erst geöffnet, nachdem mit dem Makro +% \cs{tud@declare@special@start} das obligatorische Argument~-- sprich die +% Klasse oder das Paket~-- deklariert wird. Die Umgebung \env{Bundle*} sollte +% dabei direkt nach einer Gliederungsüberschrift genutzt werden, in welcher das +% zu deklarierende Element (Klasse, Paket etc.) genannt wird, da der Anker des +% erzeugten Labels weiter nach oben auf die Höhe der Überschirft verschoben +% wird. Zum Abschluss der Deklaration wird \cs{tud@declare@special@end} nach +% dem Schließen der Umgebung \env{Bundle} genutzt. +% \begin{macrocode} +\NewDocumentEnvironment{Bundle*}{om}{% + \tud@declare@special@start[#1]{#2}{3}% + \Bundle{#2}% +}{% + \endBundle% + \tud@declare@special@end{#2}% +} +% \end{macrocode} +% \end{environment}^^A Bundle* +% \begin{macro}{\tud@declare@special@start} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\tud@declare@special@end} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Die beiden dienen zur vereinfachten Deklaration. Es wird keine Ausgabe +% sondern lediglich Hyperlink, Indexeintrag und Änderungsnotiz erzeugt. Das +% optionale Argument dient einem Änderungseintrag, das erste obligaotrische +% gilt der eigentlichen Deklaration, das zweite zur Einstellung des Makros +% \cs{tud@declare@num}, mit welchem das Verhalten für das Erzeugen der Labels +% gesteuert wird. +% \begin{macrocode} +\NewDocumentCommand\tud@declare@special@start{omm}{% + \Changed@At@CreateList(#2){#1}% + \def\tud@declare@num{#3}% + \@tud@declaretrue\@openindextrue#2\@tud@declarefalse% + \def\tud@declare@num{0}% +} +\newcommand*\tud@declare@special@end[1]{% + \ifx\tud@changedat@list\relax\else% + \ClassError{tudscrmanual}{\string\printchangedatlist\space is missing}{% + \string\tud@changedat@list\space is not empty. Did you\MessageBreak% + forget to print this list with \string\printchangedatlist?% + }% + \fi% + \@tud@declaretrue\@openindexfalse#1\@tud@declarefalse% +} +% \end{macrocode} +% \end{macro}^^A \tud@declare@special@end +% \end{macro}^^A \tud@declare@special@start +% \begin{macro}{\printdeclarationlist} +% \begin{length}{\tud@lastskip} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\index} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\label} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Mit dem Befehl \cs{printdeclarationlist} erfolgt die eingentliche Ausgabe +% aller Deklarationen. Zweck ist es, mehrere \env{Declaration}-Umgebungen +% ineinander verschachteln zu können und eine Ausgabe aller auf einmal zu +% erzeugen. Die durch die ggf. nacheinander folgenden Deklarationen wurden in +% entsprechenden Listen gesammelt und werden hier jetzt formatiert ausgegben. +% +% Da die Verwendung der Befehle \cs{index} und \cs{label} nach Überschriften +% dazu führt, dass \cs{addvspace} nicht mehr richtig verendet werden kann, +% wird hier etwas gebastelt, damit das trotzdem funktioniert. Dabei wird +% einfach bei der verwendung der genannten Befehle der zuvor gesetzte vertikale +% Abstand in \cs{tud@lastskip} gesichert. +% \begin{macrocode} +\newskip\tud@lastskip +\pretocmd{\index}{\tud@lastskip=\lastskip}{}{\tud@patch@wrn{index}} +\pretocmd{\label}{\tud@lastskip=\lastskip}{}{\tud@patch@wrn{label}} +\NewDocumentCommand\printdeclarationlist{!s !d()}{% + \ifx\tud@declaration@list\relax\else% + \ifhmode% + \vskip\medskipamount% + \else% +% \end{macrocode} +% Im vertikalen modus wird dann einfach vom eigentlich gewünschten Abstand der +% durch \cs{label} bzw. \cs{index} erzwungene vertikale Freiraum abgezogen. +% Sollte dann noch ein positiver Wert bestehen, wird dieser einfach zusätzlich +% gesetzt. +% \begin{macrocode} + \@tempskipa=\glueexpr\medskipamount-\tud@lastskip\relax% + \ifdim\@tempskipa>\z@\relax% + \addpenalty{\@beginparpenalty}% + \addvspace{\@tempskipa}% + \fi% + \fi% +% \end{macrocode} +% Anschließend wird die Länge auf jeden Fall zurückgesetzt. +% \begin{macrocode} + \global\tud@lastskip=\z@% + \@afterindentfalse\@afterheading% + \@tud@declaretrue\@openindextrue% +% \end{macrocode} +% Die deklarierten Optionen, Umgebungen, Befehle etc. werden umrahmt. Dabei +% erfolgt die Ausgabe mithilfe einer Box, um die Größe des Deklarationsrahmens +% zu speichern und die Änderungsmarkierung am Seitenrand auf die richtige Höhe +% zu platzieren. Da innerhalb von Tabellen der Wert von \cs{baselineskip} auf +% \makeatletter\the\z@\makeatother~gesetzt wird, muss für einen richtig +% platzierten Link dieser in \cs{HyperRaiseLinkDefault} gesichert werden. +% \begin{macrocode} + \def\@tempa##1{\ignorespaces##1\tabularnewline}% + \edef\HyperRaiseLinkDefault{\the\baselineskip}% + \sbox\z@{% + \begin{tabular}{|l|}% + \hline% + \forlistloop\@tempa{\tud@declaration@list}% + \hline% + \end{tabular}% + }\usebox\z@% + \@tud@declarefalse% +% \end{macrocode} +% Danach werden ggf. die Voreinstellungen und Zusatzinformationen in etwas +% kleinerer Schrift gesetzt. +% \begin{macrocode} + \ifboolexpr{bool {@tud@preset@list} or bool {@tud@additional@list}}{% + \def\@tempa##1{\small\ignorespaces##1\tabularnewline}% + \hskip1.2em% + \if@tud@preset@list% + \begin{tabular}{@{}l@{}}% + \forlistloop\@tempa{\tud@preset@list}% + \end{tabular}% + \hspace{\tabcolsep}% + \fi% + \if@tud@additional@list% + \begin{tabular}{@{}l@{}}% + \forlistloop\@tempa{\tud@additional@list}% + \end{tabular}% + \fi% + }{}% +% \end{macrocode} +% Alle für die Deklaration verwendeten Listen werden nach ihrer Abarbeitung +% zurückgesetzt. +% \begin{macrocode} + \global\let\tud@declaration@list\relax% + \global\let\tud@preset@list\relax% + \global\let\tud@additional@list\relax% + \global\@tud@preset@listfalse% + \global\@tud@additional@listfalse% +% \end{macrocode} +% Die Einträge in der Änderungsliste sowie die dazugehörige Randnotiz werden +% innerhalb der Deklaration mit \cs{printchangedatlist} erzeugt. Das optionale +% Argument sorgt für die Verschiebung der Randnotiz auf die richtige Höhe, um +% den Höhenversatz zwischen Randnotiz und Deklarationsrahmen auszugleichen. +% \begin{macrocode} + \print@changedatlist{#1}{% + \dimexpr.5\ht\strutbox+.5\dp\strutbox-.5\ht0-.5\dp0\relax% + }% +% \end{macrocode} +% Zum Schluss wird das optionale Argument (in runden Klammern) neben der +% Deklarationsbox ausgegeben. +% \begin{macrocode} + \IfValueT{#2}{#2}% + \par\nobreak% + \vskip\medskipamount% + \@afterindentfalse\@afterheading% + \fi% +} +% \end{macrocode} +% \end{macro}^^A \label +% \end{macro}^^A \index +% \end{length}^^A \tud@lastskip +% \end{macro}^^A \printdeclarationlist +% \begin{macro}{\printobsoletelist} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Damit werden Deklarationen der Umgebung \env{Obsolete} ausgegeben. +% \begin{macrocode} +\newcommand*\printobsoletelist{% + \@tud@obsoletetrue% + \printdeclarationlist*% + \@tud@obsoletefalse% +} +% \end{macrocode} +% \end{macro}^^A \printobsoletelist +% \begin{macro}{\printchangedatlist} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Damit werden Änderungsnotizen der Umgebungen \env{Declaration*}, \env{Bundle} +% und \env{Bundle*} ausgegeben. +% \begin{macrocode} +\NewDocumentCommand\printchangedatlist{!s !O{\z@}}{% + \print@changedatlist{#1}{#2}% +} +% \end{macrocode} +% \end{macro}^^A \printchangedatlista +% +% \iffalse +%</class> +% \fi +% +% \subsection{Markup von Klassen, Paketen, Optionen und weiteren Elementen} +% +% Es folgen die Definitionen für Befehle und Umgebungen für Klasse und Paket, +% welche sich überschneidenden und für beide benötigt werden. Allerdings sind +% diese für Klasse und Paket in ihrer Implementierung teilweise unterschiedlich. +% +% Als erstes werden für Klasse und Paket einige Hilfmakros definiert. +% +% \begin{macro}{\bsc} +% \changes{v2.02}{2014/07/22}{\cs{newrobustcmd} aus \pkg{etoolbox} anstatt +% \cs{DeclareRobustCommand}}^^A +% Eine einfacher zu verwendende Kurzform. +% \begin{macrocode} +\newrobustcmd*\bsc{\@backslashchar} +% \end{macrocode} +% \end{macro}^^A \bsc +% \begin{macro}{\suffix} +% \changes{v2.05}{2015/10/27}{neu}^^A +% Für alle möglichen, zusätzlichen Informationen bei Deklarationen, im Index +% oder der normalen in Ausgabe im Fließtext wird eine etwas kleinere Schrift +% verwendet. +% \begin{macrocode} +\newrobustcmd*\suffix[1]{\begingroup~\scriptsize(#1)\endgroup} +% \end{macrocode} +% \end{macro}^^A \suffix +% \begin{macro}{\NewExpandableDocumentCommand} +% \changes{v2.02}{2014/11/04}{neu}^^A +% \changes{v2.05i}{2017/03/12}{wird mittlerweile von \pkg{xparse} definiert}^^A +% Für Labels, Index- und Änderungs- sowie PDF-Outline-Einträge etc. müssen ganz +% bestimmte Markup-Befehle durch eine expandierbare Version ersetzt werden. Um +% dies möglichst einfach zu gestalten, wird \cs{NewExpandableDocumentCommand} +% definiert. +% \begin{macrocode} +\providecommand*\NewExpandableDocumentCommand[3]{% + \NewDocumentCommand#1{#2}{}% + \DeclareExpandableDocumentCommand#1{#2}{#3}% +} +% \end{macrocode} +% \end{macro}^^A \NewExpandableDocumentCommand +% +% \subsubsection{Definition der Markup-Befehle} +% +% \changes{v2.05}{2015/11/02}{Markup-Befehle komplett überarbeitet}^^A +% +% Im Folgenden werden allerhand Befehle mit Hilfe des Paketes \pkg{xparse} +% definiert, um bestimmte Begriffe, Klassen, Pakete, Optionen, Umgebungen, +% Befehle, Parameter, Bezeichner, Längen, Schriftelemente und Farben speziell +% auszuzeichnen. Diese Befehle lauten für Klasse und Paket aus Gründen der +% Konsistenz zwar gleich, unterschieden sich jedoch ein klein wenig in der +% Implementierung. +% +% Die Sternversion all dieser Befehlen tragen nichts in den Index ein. Für +% (fast) alle der folgenden Befehle gilt, dass diese mit zwei optionalen +% Argumenten am Ende genutzt werden können. Sollte ein Label existieren, wird +% automatisch ein Hyperlink erzeugt, welcher mit der optionalen Angabe von +% |'|\meta{Referenzvariante}|'| um einen textuellen Querverweis ergänzt werden +% kann. Mit \verb=|=\meta{Indexmarkup}\verb=|= kann die Erscheinung im Index +% angepasst werden. Bei einigen Befehlen kann zusätzlich zuvor im Markup mit +% dem optionalen Argument \parg{Bundleelement} die Zuweisung auf ein bestimmtes +% Paket oder eine Klasse aus dem \TUDScript-Bundle erfolgen. +% +% Die eigentliche Behandlung erfolgt mit dem Befehl \cs{Process@Markup}, +% welcher die tatsächliche Auszeichnung im Fließtext bzw. als Deklaration +% übernimmt. Das Auszeichnungsformat wird dafür zuvor mit \cs{Markup@SetFormat} +% festgelegt. Ein Eintrag in den Index wird mit \cs{Process@Index} realisiert. +% Für die Änderungsliste wird der Befehl \cs{Process@ChangedAt} genutzt, um die +% entsprechende Formatierung zu gewährleisten, wobei dies nur für die Klasse +% \cls{tudscrmanual} und nicht für das Paket \pkg{tudscrtutorial} gilt. +% +% \begin{macro}{\ProcessorKeyVal} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\tud@keyval@error} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Bei Optionen und Parametern können spezielle Werte einfach im Hauptargument +% durch |=| getrennt angegeben werden. Um diese auszuwerten, wird dieser Befehl +% definiert, welcher als Argumentprozessor verwendet wird. +% \begin{macrocode} +\newcommand*\ProcessorKeyVal[1]{% + \begingroup% + \in@{=}{#1}% +% \end{macrocode} +% Wird im Argument ein |=| gefunden, so wird alles Darauffolgende als Wert +% erkannt und dem eigentlichen Hauptargument bei der Ausgabe angehangen. Das +% Makro, welches diesen Argumentprozessor verwendet, erhält als Ausgabe also +% entweder \marg{Schlüssel} oder \marg{Schlüssel}|=|\meta{Wert}|=| falls +% \cs{ProcessorKeyVal} mit \marg{Schlüssel=Wert} verwendet wurde. +% \begin{macrocode} + \ifin@% + \def\@tempa##1=##2\@nil{\toks@{{##1}=##2=}}% + \else% + \def\@tempa##1\@nil{\toks@{{##1}}}% + \fi% + \@tempa#1\@nil% + \edef\tud@reserved{% + \noexpand\endgroup% + \def\noexpand\ProcessedArgument{\the\toks@}% + }% + \tud@reserved% +} +% \end{macrocode} +% Es gibt auch noch eine interne Variante für ein optioneles Werte-Argument. +% Dabei sollte vermieden werden, dass im Markup das Argument für einen Wert +% doppelt angegeben wird. In diesem Fall wird dieser Fehler ausgegeben. +% \begin{macrocode} +\newcommand*\tud@keyval@error{% +%<*class> + \ClassError{tudscrmanual}% +%</class> +%<*package> + \PackageError{tudscrtutorial}% +%</package> + {Wrong usage of optional argument for value}% + {There are two optional arguments for a value given!}% +} +% \end{macrocode} +% \end{macro}^^A \tud@keyval@error +% \end{macro}^^A \ProcessorKeyVal +% \begin{environment}{Bundle} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\tud@bdl@curr} +% \changes{v2.05}{2015/08/04}{neu}^^A +% \begin{macro}{\tud@bdl@dflt} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\tud@if@bdl} +% \changes{v2.05}{2015/08/04}{neu}^^A +% Die Umgebung \env{Bundle} kann nicht verschachtelt werden und prüft zuerst +% dementsprechend die Verwendung. Anschließend wird lediglich das Makro +% \cs{tud@bdl@curr} auf das übergebene Argument gesetzt, um innerhalb der +% Umgebung erstellte Label und Indexeinträge zu beeinflussen. +% \begin{macrocode} +\newenvironment{Bundle}[1]{% + \tud@if@bdl{% +%<*class> + \ClassError{tudscrmanual}% +%</class> +%<*package> + \PackageError{tudscrtutorial}% +%</package> + {Nested environment `Bundle'}{% + It is not possible to nest this environment, when\MessageBreak% + a cross-label was given before.% + }% + }{% + \gdef\tud@bdl@curr{#1}% + }% + \ignorespaces% +}{% + \global\let\tud@bdl@curr\tud@bdl@dflt% + \aftergroup\ignorespaces% +} +% \end{macrocode} +% Diese Makros werden für das Definieren eines Bundle-Elements und ggf. das +% Prüfen des selbigen benötigt. +% \ToDo{Suffixe wie Klasse, Paket etc. lokalisieren (locale)}[v2.??] +% \begin{macrocode} +\newcommand*\tud@bdl@curr{} +\newcommand*\tud@bdl@dflt{tudscr} +\let\tud@bdl@curr\tud@bdl@dflt +\newcommand*\tud@if@bdl[2]{\ifstr{\tud@bdl@curr}{\tud@bdl@dflt}{#2}{#1}} +% \end{macrocode} +% \end{macro}^^A \tud@if@bdl +% \end{macro}^^A \tud@bdl@dflt +% \end{macro}^^A \tud@bdl@curr +% \end{environment}^^A Bundle +% \begin{macro}{\Application} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\@Application} +% Die Auszeichnung und der Indexeintrag einer Anwendungssoftware. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Application{sm}{#2} +\NewDocumentCommand\Application{s m !d() !d<> !d||}{% + \Markup@SetFormat{\sbsfont}% + \IfValueTF{#4}{% + \Process@Markup{\Application{#2}}(#3)<#4>% + }{% + \Process@Markup{\Application{#2}}(#3)% + }% + \Process@Index{#1}{\Application{#2}}[Anwendungssoftware](#3)|#5|% +} +% \end{macrocode} +% \end{macro}^^A \@Application +% \end{macro}^^A \Application +% \begin{macro}{\Distribution} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\@Distribution} +% Die Auszeichnung und der Indexeintrag einer \LaTeX-Distribution. Das +% optionale Argument kann für das Anhängen einer Versionsnummer o.\,ä. im +% Fließtext genutzt werden. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Distribution{sm}{#2} +\NewDocumentCommand\Distribution{s m !o !d() !d||}{% + \Markup@SetFormat{\sbnfont}% + \IfValueTF{#3}{% + \Process@Markup{\Distribution{#2}}[~#3](#4)% + }{% + \Process@Markup{\Distribution{#2}}(#4)% + }% + \Process@Index{#1}{\Distribution{#2}}[Distribution](#4)|#5|% +} +% \end{macrocode} +% \end{macro}^^A \@Distribution +% \end{macro}^^A \Distribution +% \begin{macro}{\Engine} +% \changes{v2.05}{2015/11/04}{neu}^^A +% \begin{macro}{\@Engine} +% \changes{v2.05}{2015/11/04}{neu}^^A +% Die Auszeichnung und der Indexeintrag für ein bestimmtes Textsatzsystem. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Engine{sm}{#2} +\NewDocumentCommand\Engine{s m !d() !d||}{% + \Markup@SetFormat{\sbnfont}% + \Process@Markup{\Engine{\hologo{#2}}}(#3)% + \Process@Index{#1}{\Engine{#2}}[Textsatzsystem](#3)|#4|% +} +% \end{macrocode} +% \end{macro}^^A \@Engine +% \end{macro}^^A \Engine +% \begin{macro}{\Path} +% Pfade werden ohne zusätzliches Markup ausgegeben. +% \begin{macrocode} +\newrobustcmd*\Path[1]{\mbox{\texttt{#1}}} +% \end{macrocode} +% \end{macro}^^A \Path +% \begin{macro}{\File} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\@File} +% Die Auszeichnung und der Indexeintrag einer Datei. +% \begin{macrocode} +\NewExpandableDocumentCommand\@File{sm}{#2} +\NewDocumentCommand\File{s m !d() !d||}{% + \Markup@SetFormat{\sbnfont}% + \Process@Markup{\File{#2}}(#3)% + \Process@Index{#1}{\File{#2}}[Datei](#3)|#4|% +} +% \end{macrocode} +% \end{macro}^^A \@File +% \end{macro}^^A \File +% \begin{macro}{\Class} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\@Class} +% Die Auszeichnung und der Indexeintrag einer Klasse. Das optionale Argument +% zwischen Apostrophen kann für die Formatierung eines Querverweises im Text +% genutzt werden, das optionale Argument zwischen senkrechten Strichen dient +% der Formatierung des Indexeintrages. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Class{sm}{#2} +\NewDocumentCommand\Class{s m !d() !d'' !d||}{% +%<*class> + \if@tud@changedat% + \Process@ChangedAt{\Class{#2}}[Klasse]% + \else% +%</class> + \Markup@SetFormat{\sbnfont}% + \Process@Markup{\Class{#2}}(#3)'#4'% + \Process@Index{#1}{\Class{#2}}[Klasse](#3)|#5|% +%<*class> + \fi% +%</class> +} +% \end{macrocode} +% \end{macro}^^A \@Class +% \end{macro}^^A \Class +% \begin{macro}{\Package} +% \changes{v2.02}{2014/07/10}{Ausgabe für Änderungsliste hinzugefügt}^^A +% \begin{macro}{\@Package} +% Für die Auszeichnungen von Paketen gelten vorherigen Aussagen äquivalent. +% Für Pakete wird ergänzend ein Hyperlink auf CTAN erzeugt, wenn für dieses +% kein Label im Dokument besteht. Genaueres ist der Beschreibung und Definition +% von \cs{Process@Markup} zu entnehmen. Das optionale Argument in einfachen +% Guillemets dient zum Anpassen des CTAN-Links, welcher normalerweise aus +% obligatorischen Argument generiert wird. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Package{sm}{#2} +\NewDocumentCommand\Package{s m !d() !d<> !d'' !d||}{% +%<*class> + \if@tud@changedat% + \Process@ChangedAt{\Package{#2}}[Paket]% + \else% +%</class> + \Markup@SetFormat{\sbnfont}% + \IfValueTF{#4}{% + \Process@Markup{\Package{#2}}(#3)<#4>'#5'% + }{% + \Process@Markup{\Package{#2}}(#3)<#2>'#5'% + }% + \Process@Index{#1}{\Package{#2}}[Paket](#3)|#6|% +%<*class> + \fi% +%</class> +} +% \end{macrocode} +% \end{macro}^^A \@Package +% \end{macro}^^A \Package +% \begin{macro}{\Option} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\Option@Value} +% \changes{v2.05}{2015/11/02}{neu}^^A +% \begin{macro}{\@Option} +% \changes{v2.02}{2014/11/02}{neu}^^A +% Im Gegensatz zu den vorherigen Befehlen, kann im Hauptargument ein spezieller +% Wert für eine Option optional durch ein |=| getrennt angegeben werden. Durch +% den Argumentprozessor \cs{ProcessorKeyVal} wird dieses vom eigentlichen +% Schlüssel getrennt. Dabei wird der gegebene Schlüssel immer in der Form +% \marg{Schlüssel} ausgegeben. Sollte ein optionaler Wert gegeben worden sein, +% wird dieser in der Form |=|\meta{Wert}|=| einfach angehängt und als optionales +% Argument von \cs{Option@Value} weiter verarbeitet. Mit dem optionalen Argument +% in runden Klammern kann ggf. auf eine Option aus einem \TUDScript-Paket +% verwiesen werden. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Option{sm}{#2} +\NewDocumentCommand\Option{s >{\ProcessorKeyVal}m !d== !d() !d'' !d||}{% + \Option@Value{#1}#2=#3=(#4)'#5'|#6|% +} +% \end{macrocode} +% Für die interne Verwendung kann das optionale Argument für den Wert auch +% direkt mit |=|\meta{Wert}|=| angehangen werden. Um die gleichzeitige +% Verwendung beider Varianten zu unterdrücken, wird in diesem Fall ein Fehler +% erzeugt. +% \ToDo{% +% Eigentlich sollte der Wert hier formatiert werden. Wünschenswert wäre die +% Angabe von \val{Option=Wert} und \val{Option=<Spezialwert>}, damit das +% Gezerre mit der Spezialbehandlung von \cs{PSet} etc. wegfallen könnte, +% siehe \cs{tud@declare@start} +% }[v2.??]% +% \begin{macrocode} +\NewDocumentCommand\Option@Value{mmd==d==d()d''d||}{% + \IfValueT{#4}{\tud@keyval@error}% +%<*class> + \if@tud@changedat% + \Process@ChangedAt{\Option{#2}}=#3=[Option](#5)% + \else% +%</class> + \Markup@SetFormat{\ttfamily}% + \Process@Markup{\Option{#2}}=#3=(#5)'#6'% + \Process@Index{#1}{\Option{#2}}=#3=(#5)|#7|% +%<*class> + \fi% +%</class> +} +% \end{macrocode} +% \end{macro}^^A \@Option +% \end{macro}^^A \Option@Value +% \end{macro}^^A \Option +% \begin{macro}{\Environment} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\@Environment} +% \changes{v2.02}{2014/11/02}{neu}^^A +% Bei diesem Makro dient das optionale Argument für die Ausgabe der möglichen +% Umgebungsargumente bzw. -parameter \emph{bei der Deklaration}. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Environment{sm}{#2} +\NewDocumentCommand\Environment{s m !o !d() !d'' !d||}{% +%<*class> + \if@tud@changedat% + \Process@ChangedAt{\Environment{#2}}[Umgebung](#4)% + \else% +%</class> +% \end{macrocode} +% Außerdem wird für den Fall, dass der \cs{Environment}-Befehl innerhalb der +% Umgebung \env{Declaration} verwendet wird, eine spezielle Ausgabe erzeugt. +% Nur hier kommt das optionale Argument von \cs{Markup@SetFormat} nach dem +% Hauptargument zum Tragen. Die resultierende Ausgabe hat die Gesatlt: +% +% \begin{tabular}{l}% +% \cs{begin}\marg{Umgebung}\tabularnewline +% \dots\tabularnewline +% \cs{end}\marg{Umgebung}\tabularnewline +% \end{tabular}% +% \begin{macrocode} + \Markup@SetFormat{\ttfamily}(% + \ttfamily\bsc{}begin\textbraceleft#2\textbraceright\IfValueT{#3}{#3}% + \tabularnewline\ttfamily\dots% + \tabularnewline\ttfamily\bsc{}end\textbraceleft#2\textbraceright% + )% + \Process@Markup{\Environment{#2}}[#3](#4)'#5'% + \Process@Index{#1}{\Environment{#2}}[Umgebung](#4)|#6|% +%<*class> + \fi% +%</class> +} +% \end{macrocode} +% \end{macro}^^A \@Environment +% \end{macro}^^A \Environment +% \begin{macro}{\Macro} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\@Macro} +% \changes{v2.02}{2014/11/02}{neu}^^A +% Die Auszeichnung und der Indexeintrag eines Befehls. Das ordinäre optionale +% Argument ist für das Anhängen von Parametern o.\,ä. nach dem eigentlichen +% Makro zu verwenden. Das optionale Argument in runden Klammern dient dem +% Hyperlink zu einem Befehl aus einem anderen Paket oder einer anderen Klasse +% aus dem \TUDScript-Bundle. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Macro{sm}{#2} +\NewDocumentCommand\Macro{s m !o !d() !d'' !d||}{% +%<*class> + \if@tud@changedat% + \Process@ChangedAt{\Macro{#2}}[Befehl](#4)% + \else% +%</class> + \Markup@SetFormat[\bsc]{\ttfamily}% + \Process@Markup{\Macro{#2}}[#3](#4)'#5'% + \Process@Index{#1}{\Macro{#2}}(#4)|#6|% +%<*class> + \fi% +%</class> +} +% \end{macrocode} +% \end{macro}^^A \@Macro +% \end{macro}^^A \Macro +% \begin{macro}{\Length} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\@Length} +% Die Auszeichnung und der Indexeintrag einer \LaTeX-Länge. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Length{sm}{#2} +\NewDocumentCommand\Length{s m !d() !d'' !d||}{% +%<*class> + \if@tud@changedat% + \Process@ChangedAt{\Length{#2}}[L\"ange](#3)% + \else% +%</class> + \Markup@SetFormat[\bsc]{\ttfamily}[L\"ange]% + \Process@Markup{\Length{#2}}(#3)'#4'% + \Process@Index{#1}{\Length{#2}}[L\"ange](#3)|#5|% +%<*class> + \fi% +%</class> +} +% \end{macrocode} +% \end{macro}^^A \@Length +% \end{macro}^^A \Length +% \begin{macro}{\Counter} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% Die Auszeichnung und der Indexeintrag einer \LaTeX-Zählers. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Counter{sm}{#2} +\NewDocumentCommand\Counter{s m !d() !d'' !d||}{% +%<*class> + \if@tud@changedat% + \Process@ChangedAt{\Counter{#2}}[Z\"ahler](#3)% + \else% +%</class> + \Markup@SetFormat{\ttfamily}[Z\"ahler]% + \Process@Markup{\Counter{#2}}(#3)'#4'% + \Process@Index{#1}{\Counter{#2}}[Z\"ahler](#3)|#5|% +%<*class> + \fi% +%</class> +} +% \end{macrocode} +% \end{macro}^^A \Counter +% +% \iffalse +%<*class> +% \fi +% +% \minisec{Exklusive Auszeichnungen für die Klasse} +% Alle weiteren Befehle werden ausschließlich für die Klasse \cls{tudscrmanual} +% definiert. +% +% \begin{macro}{\Key} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\Key@Value} +% \changes{v2.05}{2015/11/02}{neu}^^A +% \begin{macro}{\@Key} +% Die Auszeichnung und der Indexeintrag eines Parameters für Umgebungen und +% Befehle. Das erste Argument ist die Umgebung oder der Befehl, wofür der +% Parameter gültig ist. Das zweite Argument ist der Parameter selbst. Die +% optionale Zuweisung eines Wertes kann äquivalent zu \cs{Option} mit dem +% Trennzeichen~|=| im Hauptargument erfolgen. +% \ToDo{% +% Eigentlich sollte der Wert hier formatiert werden. Die Angabe von +% \val{Parameter=Wert} und \val{Parameter=<Spezialwert>} wäre gut, damit +% das Gezerre mit der Spezialbehandlung von \cs{PSet} etc. wegfallen könnte, +% siehe \cs{tud@declare@start} +% }[v2.??]% +% \begin{macrocode} +\NewExpandableDocumentCommand\@Key{smm}{#2!#3} +\NewDocumentCommand\Key{s m >{\ProcessorKeyVal}m !d== !d() !d'' !d||}{% + \Key@Value{#1}{#2}#3=#4=(#5)'#6'|#7|% +} +\NewDocumentCommand\Key@Value{mmmd==d==d()d''d||}{% + \IfValueT{#5}{\tud@keyval@error}% + \if@tud@changedat% + \Process@ChangedAt{\Key{#2}{#3}}=#4=[Parameter](#6)% + \else% + \Markup@SetFormat{\ttfamily}[Parameter]% + \Process@Markup{\Key{#2}{#3}}=#4=(#6)'#7'% + \Process@Index{#1}{\Key{#2}{#3}}=#4=(#6)|#8|% + \fi% +} +% \end{macrocode} +% \end{macro}^^A \@Key +% \end{macro}^^A \Key@Value +% \end{macro}^^A \Key +% \begin{macro}{\Term} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\@Term} +% Die Auszeichnung und der Indexeintrag eines sprachabhängigen Bezeichners. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Term{sm}{#2} +\NewDocumentCommand\Term{s m !d() !d'' !d||}{% + \if@tud@changedat% + \Process@ChangedAt{\Term{#2}}[Bezeichner](#3)% + \else% + \Markup@SetFormat[\bsc]{\ttfamily}[Bezeichner]% + \Process@Markup{\Term{#2}}(#3)'#4'% + \Process@Index{#1}{\Term{#2}}(#3)|#5|% + \fi% +} +% \end{macrocode} +% \end{macro}^^A \@Term +% \end{macro}^^A \Term +% \begin{macro}{\PageStyle} +% \changes{v2.02}{2014/07/25}{neu}^^A +% \begin{macro}{\@PageStyle} +% Die Auszeichnung und der Indexeintrag eines Seitenstils. +% \begin{macrocode} +\NewExpandableDocumentCommand\@PageStyle{sm}{#2} +\NewDocumentCommand\PageStyle{s m !d() !d'' !d||}{% + \if@tud@changedat% + \Process@ChangedAt{\PageStyle{#2}}[Seitenstil](#3)% + \else% + \Markup@SetFormat{\ttfamily}[Seitenstil]% + \Process@Markup{\PageStyle{#2}}(#3)'#4'% + \Process@Index{#1}{\PageStyle{#2}}[Seitenstil](#3)|#5|% + \fi% +} +% \end{macrocode} +% \end{macro}^^A \@PageStyle +% \end{macro}^^A \PageStyle +% \begin{macro}{\Font} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\@Font} +% Die Auszeichnung und der Indexeintrag eines Schriftelementes. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Font{sm}{#2} +\NewDocumentCommand\Font{s m !d() !d'' !d||}{% + \if@tud@changedat% + \Process@ChangedAt{\Font{#2}}[Schriftelement](#3)% + \else% + \Markup@SetFormat{\ttfamily}[Schriftelement]% + \Process@Markup{\Font{#2}}(#3)'#4'% + \Process@Index{#1}{\Font{#2}}[Schriftelement](#3)|#5|% + \fi% +} +% \end{macrocode} +% \end{macro}^^A \@Font +% \end{macro}^^A \Font +% \begin{macro}{\Color} +% \changes{v2.02}{2014/10/08}{überarbeitet}^^A +% \begin{macro}{\@Color} +% Die Auszeichnung und der Indexeintrag einer Farbe des \CDs. Das optionale +% Argument kann sowohl bei der Deklaration als auch im Fließtext für das +% Anhängen eines Suffix verwendet werden. Alle mit \cs{Color} ausgezeichneten +% Farben referenzieren standardmäßig auf das Paket \pkg{tudscrcolor}. +% \begin{macrocode} +\NewExpandableDocumentCommand\@Color{sm}{#2} +\NewDocumentCommand\Color{s m !o !D(){\Package{tudscrcolor}} !d'' !d||}{% + \if@tud@changedat% + \Process@ChangedAt{\Color{#2}}[Farbe](#4)% + \else% + \Markup@SetFormat{\ttfamily}[Farbe](% + \begingroup\ttfamily{#2\IfValueT{#3}{~(#3)}}\endgroup% + )% + \Process@Markup{\Color{#2}}[#3](#4)'#5'% + \Process@Index{#1}{\Color{#2}}[Farbe](#4)|#6|% + \fi% +} +% \end{macrocode} +% \end{macro}^^A \@Color +% \end{macro}^^A \Color +% +% \iffalse +%</class> +% \fi +% +% \subsubsection{Zuordnung der Markup-Befehle für Label und Index} +% +% \begin{macro}{\tud@attr@get} +% \changes{v2.05}{2015/11/03}{neu}^^A +% Der Befehl \cs{tud@attr@get} ordnet den einzelnen Markup-Befehlen ihren +% spezifischen Präfix für ein Label oder in der Sternversion den passenden +% Index zu. Im ersten obligatorischen Argument wird ein Makro angegeben, +% welches die Zuordnung enthalten soll, das zweite ist der Markup-Befehl selbst. +% \begin{macrocode} +\NewDocumentCommand\tud@attr@get{smm}{% + \begingroup% +% \end{macrocode} +% Das temporäre Makro \cs{@tempa} definiert zunächst alle Markup-Befehle in +% einer Gruppe neu und expandiert beim Aufruf jedes dieser lokal umdefinierten +% Markup-Befehle~-- abhängig vom Aufruf von \cs{tud@attr@get} mit oder ohne +% Stern~-- entweder zum Markup-Befehl passenden Index oder zum entsprechenden +% Labelpräfix in \cs{@tempb}. +% \begin{macrocode} + \def\@tempa##1##2##3{% + \def##1####1{% + \edef\@tempb{\IfBooleanTF{#1}{##2}{##3}}% + }% + }% + \@tempa\Application{\jobname}{app}% + \@tempa\Distribution{\jobname}{dst}% + \@tempa\Engine{\jobname}{eng}% + \@tempa\File{files}{fle}% + \@tempa\Class{files}{cls}% + \@tempa\Package{files}{pkg}% + \@tempa\Option{options}{opt}% + \@tempa\Environment{macros}{env}% + \@tempa\Macro{macros}{cmd}% + \@tempa\Length{misc}{len}% + \@tempa\Counter{misc}{cnt}% +% \end{macrocode} +% Da \cs{Key} mit zwei Hauptargumenten aufgerufen wird, ist nur die Expansion +% des ersten Argumentes in \cs{@tempb} notwendig. +% \begin{macrocode} +%<*class> + \def\Key##1##2{% + \edef\@tempb{\IfBooleanTF{#1}{macros}{key}}% + }% + \@tempa\Term{terms}{term}% + \@tempa\PageStyle{elements}{pgs}% + \@tempa\Font{elements}{font}% + \@tempa\Color{elements}{clr}% +%</class> +% \end{macrocode} +% Nachdem alle Markup-Befehle lokal redefiniert wurden, wird der nun angegebene +% Befehl ausgeführt, was zum eigentlichen Definieren von \cs{@tempb} führt. +% \begin{macrocode} + #3% +% \end{macrocode} +% Damit alle Änderungen der temporären Makros lokal bleiben, wird das Ergebnis +% nach der Gruppe in das erste obligatorische Argument expandiert. +% \begin{macrocode} + \edef\tud@reserved{% + \noexpand\endgroup% + \def\noexpand#2{\@tempb}% + }% + \tud@reserved% +} +% \end{macrocode} +% \end{macro}^^A \tud@attr@get +% +% \subsubsection{Markup von Variablen, Parametern etc.} +% +% \ToDo{% +% Verwendung der Befehle überprüfen, evtl. umbennenen. Wozu \cs{PValueName}?% +% Evtl. sollte \cs{PValue} innerhalb von \cs{PName} lokal geändert werden? +% Was passiert, wenn auch \cs{PName} von \cs{tud@doifPValue} akzeptiert? +% Zeile 542--546 in tudscr-hints, 294 in tudscr-packages +% }[v2.??]% +% \ToDo{% +% nach '=\cs{P(Value)?Name}' in *.tex suchen und ggf. +% überarbeiten; \cs{PValueName} umbenennen% +% }[v2.??]% +% \ToDo{% +% bei der Deklaration evtl. ein Hilfsmakro erstellen und den +% Default-Eintrag hinterlegen, um ggf. darauf zu prüfen% +% }[v2.??]% +% \ToDo{% +% neues Makro \cs{PLength} mit \cs{PName\{Längenwert\}} +% }[v2.??]% +% \begin{macro}{\PValue} +% \begin{macro}{\PName} +% \begin{macro}{\PValueName} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\PSet} +% \begin{macro}{\PBoolean} +% \begin{macro}{\PBName} +% \changes{v2.02}{2014/11/12}{neu}^^A +% \begin{macro}{\Parameter} +% \begin{macro}{\OParameter} +% \begin{macro}{\LParameter} +% \begin{macro}{\OLParameter} +% \begin{macro}{\PParameter} +% \begin{macro}{\POParameter} +% \changes{v2.03}{2015/01/25}{neu}^^A +% \begin{macro}{\textOR} +% Diese Befehle dienen zum Auszeichnen von obligatorischen und optionalen +% Parametern und Befehlen oder bestimmten Wertzuweisungen. +% \begin{macrocode} +\newrobustcmd*\PValue[1]{\mbox{\texttt{#1}}} +\newrobustcmd*\PName[1]{\PValue{\textsl{<#1>}}} +\newrobustcmd*\PValueName[1]{\PName{#1}} +\newrobustcmd*\PSet{\PName{Einstellung}} +\newrobustcmd*\PBoolean{\PName{Ein-Aus-Wert}} +\newrobustcmd*\PBName[1]{\PBoolean\textOR\PName{#1}} +\newrobustcmd*\Parameter[1]{% + \mbox{\texttt{\textbraceleft}\PName{#1}\texttt{\textbraceright}}% +} +\newrobustcmd*\OParameter[1]{\mbox{\texttt{[}\PName{#1}\texttt{]}}} +\newrobustcmd*\LParameter{\mbox{\texttt{[}\PName{Parameterliste}\texttt{]}}} +\newrobustcmd*\OLParameter[1]{% + \mbox{\texttt{[}\PName{#1}\textOR\PName{Parameterliste}\texttt{]}}% +} +\newrobustcmd*\PParameter[1]{\mbox{\texttt{\textbraceleft#1\textbraceright}}} +\newrobustcmd*\POParameter[1]{\mbox{\texttt{[#1]}}} +\newrobustcmd*\textOR{\PValue{\,\textbardbl\,}} +% \end{macrocode} +% \end{macro}^^A \textOR +% \end{macro}^^A \POParameter +% \end{macro}^^A \PParameter +% \end{macro}^^A \OLParameter +% \end{macro}^^A \LParameter +% \end{macro}^^A \OParameter +% \end{macro}^^A \Parameter +% \end{macro}^^A \PBName +% \end{macro}^^A \PBoolean +% \end{macro}^^A \PSet +% \end{macro}^^A \PValueName +% \end{macro}^^A \PName +% \end{macro}^^A \PValue +% \begin{macro}{\tud@doifPValue} +% \changes{v2.05}{2015/11/14}{neu}^^A +% Der Befehl wird von den Makros \cs{tud@lbl@get@curr} und \cs{tud@idx@get} +% genutzt, um bedingten Quelltext auszuführen, falls im ersten obligatorischen +% Argument entweder Parameter entweder direkt oder aber mit einem der beiden +% Parameter-Markup-Befehle \cs{PValue} oder \cs{PValueName} angegeben wurde. +% Alle anderen Auszeichnungsbefehle für Parameter sollen ingnoriert werden. +% \begin{macrocode} +\newcommand*\tud@doifPValue[3][]{% + \IfValueT{#2}{% + \begingroup% +% \end{macrocode} +% Zunächst wird der Inhalt fast aller ausgezeichneten Parameter unterdrückt. +% Lediglich das Argument der beiden Makros \cs{PValue} und \cs{PValueName} wird +% durchgereicht.Dies wird bei der Generierung von Labeln sowie der Erstellung +% für Einträge im Index und der Änderungsliste benötigt, um die Angabe von +% speziellen Werten bei Schlüsseln zu erhalten. +% \begin{macrocode} + \let\PValue\@firstofone% + \let\PName\@gobble% + \let\PValueName\@firstofone% + \let\PSet\@empty% + \let\PBoolean\@empty% + \let\PBName\@gobble% + \let\Parameter\@gobble% + \let\OParameter\@gobble% + \let\LParameter\@empty% + \let\OLParameter\@gobble% + \let\PParameter\@gobble% + \let\POParameter\@gobble% + \let\textOR\relax% + \let\emph\@firstofone% +% \end{macrocode} +% Im optionalen Argument können weitere Angaben gemacht werden, um zum Beispiel +% weitere lokale Redefinitionen vorzunehmen. +% \begin{macrocode} + #1% +% \end{macrocode} +% Falls tatsächlich ein passendes Argument angegeben wurde, wird der Quelltext +% des zweiten obligatorischen Argumentes ausgeführt. Es ist zu beachten, dass +% dieser \emph{expandiert} wird! +% \begin{macrocode} + \ifxblank{#2}{% + \let\tud@reserved\endgroup% + }{% + \protected@edef\tud@reserved{\noexpand\endgroup#3}% + }% + \tud@reserved% + }% +} +% \end{macrocode} +% \end{macro}^^A \tud@doifPValue +% \begin{macro}{\Markup@Gobble} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Dieser Befehl definiert alle Markup-Befehle in der Form um, dass diese nur +% noch das eigentliche Hauptargument unformatiert durchreichen. Dies wird für +% die Erstellung von Label und Indexeinträgen benötigt. Die Sternversion führt +% dies auch noch für die Auszeichnung von Parametern etc. durch. +% \begin{macrocode} +\NewDocumentCommand\Markup@Gobble{s}{% + \let\Application\@Application% + \let\Distribution\@Distribution% + \let\Engine\@Engine% + \let\File\@File% + \let\Class\@Class% + \let\Package\@Package% + \let\Option\@Option% + \let\Environment\@Environment% + \let\Macro\@Macro% + \let\Length\@Length% + \let\Counter\@Counter% +%<*class> + \let\Key\@Key% + \let\Term\@Term% + \let\PageStyle\@PageStyle% + \let\Font\@Font% + \let\Color\@Color% +%</class> + \IfBooleanF{#1}{% + \let\PValue\@firstofone% + \let\PName\@firstofone% + \let\PValueName\@firstofone% + \let\PSet\relax% + \let\PBoolean\relax% + \let\PBName\@firstofone% + \let\Parameter\@firstofone% + \let\OParameter\@firstofone% + \let\LParameter\relax% + \let\OLParameter\@firstofone% + \let\PParameter\@firstofone% + \let\POParameter\@firstofone% + \let\textOR\relax% + \let\hologoRobust\@firstofone% + \def\_{-}% + \protected\def~{~}% + }% +} +% \end{macrocode} +% Mit dem zuvor definierten Makro \cs{Markup@Gobble} wird gleich dafür Sorge +% getragen, dass die Auszeichnungsbefehle für PDF-Outline-Einträge korrekt +% funktionieren. +% \begin{macrocode} +\AfterPackage*{hyperref}{% + \expandafter\pdfstringdefDisableCommands\expandafter{\Markup@Gobble}% +} +% \end{macrocode} +% \end{macro}^^A \Markup@Gobble +% +% \subsubsection{Erstellung und Validierung von Labeln} +% +% \begin{macro}{\tud@lbl@tmp} +% \changes{v2.05}{2015/11/03}{neu}^^A +% \begin{macro}{\tud@lbl@fmt} +% \changes{v2.05}{2015/11/03}{neu}^^A +% In \cs{tud@lbl@tmp} werden nachfolgend die durch \cs{tud@lbl@get@curr} oder +% \cs{tud@attr@get} erzeugten (Sub-)Label gespeichert. Mit dem Hilfsmakro +% \cs{tud@lbl@fmt} wird innerhalb der beiden Befehle \cs{tud@lbl@@create} und +% \cs{tud@lbl@get@@curr} dafür gesorgt, dass geschützte Leerzeichen sowie +% eingabekodierungsabhängige Zeichen korrekt für ein Label umgesetzt werden. +% Auch durch \cs{NoCaseChange} in Überschriften geschützte Inhalte werden +% direkt übernommen. +% \begin{macrocode} +\newcommand*\tud@lbl@tmp{} +\newcommand*\tud@lbl@fmt{% + \def~{-}% + \let\IeC\@firstofone% + \def\"##1{##1e}% + \def\ss{ss}% + \def\dots{...}% + \let\NoCaseChange\@firstofone% +} +% \end{macrocode} +% \end{macro}^^A \tud@lbl@fmt +% \end{macro}^^A \tud@lbl@tmp +% \begin{macro}{\tud@lbl@get@curr} +% \changes{v2.05}{2015/11/03}{neu}^^A +% \begin{macro}{\tud@lbl@get@@curr} +% \changes{v2.05}{2015/11/03}{neu}^^A +% Für den Befehl \cs{tud@lbl@get@curr} wird das zweite obligatorische +% Argument (|#3|) für gewöhnlich in der Form +% |{\Bundle|\marg{Klasse/Paket}|:\Markup|\marg{Element}|}| angegeben. Dieses +% wird beim Einlesen direkt an die beiden Argumentprozessoren +% \cs{SplitArgument}|{2}{:}| gefolgt von \cs{tud@lbl@create} übergeben. Danach +% enthält das zweite obligatorische Argument ein Label der Form +% \meta{Bundlepräfix}|:|\meta{Labelpräfix}|:|\meta{Element}. Auch die Angabe +% eines Makros als zweites obligatorische Argument, welches das Label in der +% richtigen Formatierung enthält, ist möglich. +% \begin{macrocode} +\NewDocumentCommand\tud@lbl@get@curr{% + sm>{\tud@lbl@create}>{\SplitArgument{2}{:}}md==% +}{% +% \end{macrocode} +% Mit \cs{tud@lbl@get@@curr} wird das im zweiten obligatorischen Argument +% (|#3|) generierte Label in das im ersten obligatorischen Argument |#2| +% angegebenen Makro gespeichert und ggf. diesem das letzte optionale Argument +% für einen speziellen Wert zu einem Schlüssel angehangen. +% \begin{macrocode} + \tud@lbl@get@@curr#2{#3}=#4=% +% \end{macrocode} +% Die Sternversion von \cs{tud@lbl@get@curr} wird für das Definieren von Labeln +% bei Deklarationen etc. genutzt. Sollte diese verwendet worden sein, ist die +% Generierung beendet. +% \begin{macrocode} +%<*class> + \IfBooleanF{#1}{% +% \end{macrocode} +% Andernfalls wird geprüft, ob das erstellte Label überhaupt existiert. Sollte +% dies nicht der Fall sein wird ein passendes Label für den gegebenen Schlüssel +% ohne speziellen Wert gesucht. +% \begin{macrocode} + \@tempswafalse% + \tud@if@lbl@exists{#2}{% + \@tempswatrue% + }{% + \IfValueT{#4}{% + \tud@lbl@get@@curr\tud@reserved{#3}% + \tud@if@lbl@exists{\tud@reserved}{% + \let#2\tud@reserved% + \@tempswatrue% + }{}% + }% + }% +% \end{macrocode} +% Wurde auch danach noch kein passendes Label gefunden, gibt es u.\,U. eine +% letzte Möglichkeit, ein passendes Label zu finden. Wird in der Dokumentation +% gerade ein Paket oder eine sich von den Hauptklassen unterscheidende Klasse +% aus dem \TUDScript-Bundle erläutert (Umgebungen \env{Bundle}, \env{Bundle*}), +% so wird eventuell auf ein Element aus ebendiesen Hauptklassen referenziert. +% In diesem Fall wird \cs{tud@lbl@get@dflt} aufgerufen, um den Bundlepräfix +% für das Label entsprechend zu setzen. +% \begin{macrocode} + \if@tempswa\else% + \tud@if@bdl{\tud@lbl@get@dflt#2{#3}=#4=}{}% + \fi% + }% +%</class> +} +% \end{macrocode} +% Mit \cs{tud@lbl@get@@curr} wird das generierte Label in Makro gespeichert, +% welches beim Aufruf von \cs{tud@lbl@get@curr} angegebenen wurde. +% \begin{macrocode} +\NewDocumentCommand\tud@lbl@get@@curr{mmd==}{% + \def#1{#2}% +% \end{macrocode} +% Sollte optional mit \cs{PValue} bzw. \cs{PValueName} ein spezieller Wert für +% einen Schlüssel übergeben worden sein, wird dieser ggf. angehängt. +% \begin{macrocode} + \tud@doifPValue[\tud@lbl@fmt]{#3}{\noexpand\appto\noexpand#1{=#3}}% +} +% \end{macrocode} +% \end{macro}^^A \tud@lbl@get@@curr +% \end{macro}^^A \tud@lbl@get@curr +% \begin{macro}{\tud@lbl@get@dflt} +% \changes{v2.05}{2015/11/04}{neu}^^A +% \begin{macro}{\tud@lbl@get@@dflt} +% \changes{v2.05}{2015/11/04}{neu}^^A +% Diese beiden Makros werden genutzt, um mit \cs{tud@lbl@get@curr} innerhalb +% der Umgebungen \env{Bundle} und \env{Bundle*} für den Fall, dass ein +% gesuchtes Label für das aktuelle Bundle-Element nicht existiert, nach diesem +% Element in den existierenden Labels der Hauptklassen zu suchen. +% +% Dabei wird das bereits generierte Label durch \cs{tud@lbl@get@dflt} in +% seine drei Hauptbestandteile zur WEiterverarbeitung zerlegt. +% \begin{macrocode} +\NewDocumentCommand\tud@lbl@get@dflt{m>{\SplitArgument{2}{:}}mr==}{% + \tud@lbl@get@@dflt{#1}#2=#3=% +} +% \end{macrocode} +% Durch \cs{tud@lbl@get@@dflt} wird als erstes geprüft, ob der Bundlepräfix +% bereits dem Standardpräfix für die Hauptklassen entspricht. Nur wenn dies +% nicht der Fall ist, wird die Labelgenerierung abermals ausgeführt. +% \begin{macrocode} +\NewDocumentCommand\tud@lbl@get@@dflt{mmmmr==}{% + \edef\tud@reserved{\expandafter\detokenize\expandafter{\tud@bdl@dflt}}% + \ifstr{\tud@reserved}{#2}{}{% +% \end{macrocode} +% Dabei erfolgt der Aufruf logischerweise mit dem richtigen Bundlepräfix. +% \begin{macrocode} + \tud@lbl@get@curr#1{\tud@bdl@dflt:#3:#4}=#5=% + }% +} +% \end{macrocode} +% \end{macro}^^A \tud@lbl@get@@dflt +% \end{macro}^^A \tud@lbl@get@dflt +% \begin{macro}{\tud@if@lbl@exists} +% \changes{v2.05}{2015/11/05}{neu}^^A +% Mit dem Befehl \cs{tud@if@lbl@exists} wird eine Fallunterscheidung bezüglich +% der Existenz eines Labels in der Form +% \meta{Bundlepräfix}|:|\meta{Labelpräfix}|:|\meta{Element} durchgeführt. Das +% zu prüfende Label ist in gleicher Weise wie beim Makro \cs{tud@lbl@get@curr} +% anzugeben. Je nachdem, ob ein existierendes Label gefunden wird oder nicht, +% wird das zweite oder das dritte obligatorische Argument ausgeführt. +% \begin{macrocode} +%<*class> +\NewDocumentCommand\tud@if@lbl@exists{% + >{\tud@lbl@create}>{\SplitArgument{2}{:}}m% +}{% + \ifcsdef{r@#1}{% + \expandafter\@firstoftwo% + }{% + \expandafter\@secondoftwo% + }% +} +%</class> +% \end{macrocode} +% \end{macro}^^A \tud@if@lbl@exists +% \begin{macro}{\tud@lbl@create} +% \changes{v2.05}{2015/11/03}{neu}^^A +% \begin{macro}{\tud@lbl@@create} +% \changes{v2.05}{2015/11/03}{neu}^^A +% Das Makro \cs{tud@lbl@@create} ist ein Argumentprozessor, welcher als Eingabe +% genau drei Argumente für das Erstellen eines gültigen Labels erwartet. Er +% wird sowohl von \cs{tud@lbl@get@curr} als auch von \cs{tud@if@lbl@exists} +% verwendet. Vor der Nutzung von \cs{tud@lbl@create} muss das Argument zuvor +% bereits mit \cs{SplitArgument}|{2}{:}| aufgerufen worden sein. Diese +% Eigenheit macht die Definition von \cs{tud@lbl@create} notwendig, um das +% Ergebnis der zuvor vorgenommenen Argumentaufspaltung verarbeiten zu können, +% in dem dieses an \cs{tud@lbl@@create} durchgereicht wird. Eine Integration +% der Spaltung des Argumentes in \cs{tud@lbl@create} ist aufgrund des +% mehrmaligen rekursiven Aufrufs von \cs{tud@lbl@create} nicht möglich. +% +% Mit dem Argumentprozessor \cs{tud@lbl@create} wird es ermöglicht, an die +% beiden Befehle \cs{tud@lbl@get@curr} und \cs{tud@if@lbl@exists} sowohl ein +% einzelnes Makro, welches das Label bereits beinhaltet als auch einen +% Markup-Befehl ggf. mit einem Bundlepräfix zu übergeben. In beiden Fällen +% wird aus dem übergebenen Argument ein eindeutiges Label in der Form +% \meta{Bundlepräfix}|:|\meta{Labelpräfix}|:|\meta{Element} generiert und als +% resultierendes Argument an das aufrufenden Makro übergeben. +% \begin{macrocode} +\NewDocumentCommand\tud@lbl@create{m}{\tud@lbl@@create#1} +% \end{macrocode} +% Es gibt insgesamt vier verschiedene Varianten der Argumentenübergabe an den +% Argumentprozessor \cs{tud@lbl@@create}. +% \begin{description}\let\itshape\slshape +% \item[\cs{tud@lbl@@create}]\ignorespaces% +% |{\LabelMakro}{-NoValue-}{-NoValue-}|\strut\newline% +% Das Label ist bereits in \cs{LabelMakro} enthalten und soll expandiert +% werden. Dabei spielt es keine Rolle, ob die durch |:| getrennten +% Bestandteile innerhalb des Labels schon als einfacher String oder in der +% Markupform gegeben sind. +% \item[\cs{tud@lbl@@create}]\ignorespaces% +% |{-NoValue-}{\Markup|\marg{Element}|}{-NoValue-}|\strut\newline% +% Das Label soll für ein Markupelement generiert werden, wobei in jedem +% Fall der Inhalt aus \cs{tud@bdl@curr} als Bundlepräfix genutzt wird. +% \item[\cs{tud@lbl@@create}]\ignorespaces% +% |{\Class/\Package|\marg{\dots}|}|\ignorespaces% +% |{\Markup|\marg{Element}|}{-NoValue-}|\strut\newline% +% Das Label soll für ein Markupelement generiert werden. +% Dabei wurde explizit ein Paket oder eine Klasse aus dem Bundle angegeben +% oder implizit das Makro \cs{tud@bdl@curr} als Argument verwendet, +% welches innerhalb der Umgebungen \env{Bundle} und \env{Bundle*} auf +% das/die aktuell beschriebene Paket/Klasse gesetzt wurde. +% \item[\cs{tud@lbl@@create}]\ignorespaces% +% \marg{Bundlepräfix}\marg{Labelpräfix}\marg{Element}\strut\newline +% Das Label ist bereits vollständig bestimmt und die Argumente werden +% entweder als String oder als Markup übergeben. Auch Mischformen sind +% möglich. In diesem Fall wird es einfach wieder zusammengesetzt. Diese +% Variante tritt durch rekursiven Aufruf des Argumentprozessors auf. +% \end{description} +% \begin{macrocode} +\NewDocumentCommand\tud@lbl@@create{mmm}{% + \begingroup% +% \end{macrocode} +% Zu Beginn werden die Markup-Befehle auf ihre expandierbaren Varianten gesetzt +% und die zusätzlichen Redefinitionen für die Labelgenerierung aktiviert. +% \begin{macrocode} + \Markup@Gobble% + \tud@lbl@fmt% +% \end{macrocode} +% Sind alle drei Bestandteile bereits vorhanden, wird das Label einfach wieder +% zusammengesetzt. +% \begin{macrocode} + \IfValueTF{#3}{% + \edef\@tempa{#1:#2:#3}% + }{% +% \end{macrocode} +% Hier geschieht die eigentliche Erzeugung der Labels. Dabei wird mit +% \cs{tud@attr@get} der für den jeweiligen Markup-Befehl aus dem zweiten +% obligatorischen Argument spezifische Labelpräfix generiert. Abhängig davon, +% ob im ersten obligatorischen Argument ein spezieller Bundlepräfix angegeben +% wurde, wird dieser entweder verwendet oder aber implizit auf den Inhalt aus +% \cs{tud@bdl@dflt} zurückgegriffen. +% \begin{macrocode} + \IfValueTF{#2}{% + \tud@attr@get\@tempb{#2}% + \IfValueTF{#1}{% + \ifxblank{#1}{% + \edef\@tempa{\tud@bdl@dflt:\@tempb:#2}% + }{% + \edef\@tempa{#1:\@tempb:#2}% + }% + }{% + \edef\@tempa{\tud@bdl@curr:\@tempb:#2}% + }% + }{% +% \end{macrocode} +% Wurde lediglich ein Makro angegeben, wird dieses einfach expandiert. +% \begin{macrocode} + \edef\@tempa{#1}% + }% + }% +% \end{macrocode} +% Das Ergebnis der Labelgenrierung wurde für alle der behandelten Fälle in +% \cs{@tempa} geschrieben. Abschließnd wird \cs{ProcessedArgument} nach der +% Gruppe mit dessen Inhalt definiert. Dabei werden bei der Expansion die +% catcodes aller Zeichen in Tokens der Klasse \val{other} gewandelt, um diese +% später sicher vergleichen zu können. +% \begin{macrocode} + \edef\@tempc{% + \noexpand\endgroup% + \def\noexpand\ProcessedArgument{% + \expandafter\detokenize\expandafter{\@tempa}% + }% + }% + \@tempc% +} +% \end{macrocode} +% \end{macro}^^A \tud@lbl@@create +% \end{macro}^^A \tud@lbl@create +% +% \subsubsection{Abarbeitung der Markup-Befehle} +% +% Die Festlegung des individuellen Markups der Einzelnen Elemente erfolgt bei +% der Definition mit \cs{Markup@SetFormat}. Bei der Nutztung der Markup-Befehle +% im Fließtext wird zum einen das in \cs{Markup@Format} individuell definierte +% Markup umgesetzt und zum anderen wird dabei gleich automatisch ein Eintrag +% für das Element im Index erzeugt. +% +% \begin{macro}{\ifdisposition} +% \changes{v2.06}{2018/08/02}{neu}^^A +% \begin{macro}{\if@tud@disposition} +% \begin{macro}{\tud@sec@format} +% Für Markup oder andere Inhalte, die lediglich im Fließtext jedoch nicht in +% Überschriften ausgegeben werden, wird der Schalter \cs{if@tud@disposition} +% und der dazugehörige auswertende Befehl \cs{ifdisposition} definiert. Das +% Setzen des Schalters wird in \cs{tud@sec@format} gepatcht. +% \begin{macrocode} +\newif\if@tud@disposition +\newcommand*\ifdisposition{% + \if@tud@disposition% + \expandafter\@firstoftwo% + \else% + \expandafter\@secondoftwo% + \fi% +} +\pretocmd{\tud@sec@format}{% + \@tud@dispositiontrue% +}{}{\tud@patch@wrn{tud@sec@format}} +% \end{macrocode} +% \end{macro}^^A \tud@sec@format +% \end{macro}^^A \if@tud@disposition +% \end{macro}^^A \tud@if@disposition +% +% In der Klasse \cls{tudscrmanual} werden die Markup-Befehle zusätzlich auch +% als Argument der Umgebung \env{Declaration} genutzt. Für diese Verwendung +% kommt die Definiton von \cs{Markup@Declare} und ggf. \cs{Markup@Suffix} zum +% Einsatz. +% +% \begin{macro}{\Process@Markup} +% \changes{v2.02}{2014/10/08}{Markup für Index und Fließtext getrennt}^^A +% \changes{v2.02}{2014/10/09}{Anpassung für Umgebung \env{Declaration*}}^^A +% \changes{v2.05}{2015/11/05}{Neuimplementierung}^^A +% \begin{macro}{\Markup@Suppress} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\Markup@@Suppress} +% \changes{v2.05}{2015/11/05}{neu}^^A +% Der Befehl \cs{Process@Markup} ist das Herzstück der Auszeichnungen aller +% Elemente. Das obligatorische Argument ist das auszuzeichnende Element selbst, +% welches im weiteren Verlauf der Abarbeitung expandiert wird. Darauf folgen +% mehrere optionale Argumente. Mit |=|\meta{Wert}|=| kann ein Wert für einen +% Schlüssel angegeben werden, was aktuell von \cs{Option} und \cs{Key} genutzt +% wird. Darauf folgend kann in einem ordinären optionalen Argument ein Suffix +% für die Fließtextausgabe angegeben werden, was von \cs{Distribution} sowie +% \cs{Environment}, \cs{Macro} und \cs{Color} verwendet wird. +% +% Mit dem optionalen Argument in runden Klammern kann eine Klasse oder ein +% Paket aus dem \TUDScript-Bundle angegeben werden, auf welche sich das +% aktuelle auszuzeichnende Element bezieht und ggf. das Label und der +% Indexeintrag dementsprechend erzeugt werden sollen. Verwendet wird es mit: +% |(\Class|\marg{Klasse}|)| oder |(\Package|\marg{Paket}|)| +% +% Das optionale Argument in Guillemets wird von \cs{Package} benötigt, um ggf. +% die automatisch generierten Links auf CTAN anzupassen. Zuletzt kann mit +% |'|\meta{Referenzvariante}|'| der automatisch erzeugte Querverweis in +% verschiedenen Varianten formatiert werden. Der vollständige Funktionsaufruf: +% \newline\begingroup\scriptsize +% \cs{Process@Markup}\marg{Element}|=|\meta{Wert}|=|\ignorespaces% +% \oarg{Ausgabesuffix}\parg{Bundleelement}\ignorespaces% +% |<|\meta{CTAN-Paket}|>||'|\meta{Referenzvariante}|'|\ignorespaces% +% \endgroup +% +% In eingen Fällen ist es beim Aufruf eines Markup-Befehls nicht erwünscht, +% dass dieser auch tatsächlich ausgegeben wird. Für diesen Fall wird gleich zu +% Beginn der Befehl \cs{Markup@Suppress} definiert, der dies ermöglicht. +% \begin{macrocode} +\newcommand*\Markup@Suppress{\let\Process@Markup\Markup@@Suppress} +\NewDocumentCommand\Markup@@Suppress{md==od()d<>d''}{} +% \end{macrocode} +% Nun folgt die eigentliche Befehlsdefinition. +% \begin{macrocode} +\NewDocumentCommand\Process@Markup{md==od()d<>d''}{% +% \end{macrocode} +% Zu Beginn wird mit dem Schalter \cs{if@tud@declare} geprüft, ob die der +% Markup-Befehl in einer der Deklarationsumgebungen oder anderweitig genutzt +% wird. Für den ersten Fall erfolgt die Weiterverarbeitung der Argumente mit +% \cs{Process@@MarkupDeclare}, andernfalls kommt \cs{Process@@MarkupInline} zum +% Einsatz. Da beide Makros die gleiche Reihenfolge der Argumente verlangen, +% wird der jeweilige Befehlsaufruf über ein Token-Register realisiert, womit +% das Zusammensetzen der notwendigen Übergabewerte erleichtert wird. +% +% Die Fallunterscheidung betrifft des Weiteren die Erzeugung des Labels. Für +% eine Deklaration wird die Sternversion von \cs{tud@lbl@get@curr} verwendet, +% welche ein Label aus den gegebenen Argumenten zusammensetzt. Ist keine +% Deklaration aktiv, versucht \cs{tud@lbl@get@curr} ein gültiges, schon +% vorhandenes Label zu verwenden. Das generierte Label wird anschließend als +% erstes Argument für das weiterverabeitende Makro genutzt. +% \begin{macrocode} +%<*class> + \if@tud@declare% + \tud@toks@{\Process@@MarkupDeclare}% + \IfValueTF{#4}{% + \tud@lbl@get@curr*\tud@lbl@tmp{#4:#1}=#2=% + }{% + \tud@lbl@get@curr*\tud@lbl@tmp{\tud@bdl@curr:#1}=#2=% + }% + \else% +%</class> + \tud@toks@{\Process@@MarkupInline}% + \tud@lbl@get@curr\tud@lbl@tmp{#4:#1}=#2=% +%<*class> + \fi% +%</class> + \eaddto@hook\tud@toks@{\expandafter{\tud@lbl@tmp}}% +% \end{macrocode} +% Danach wird der Inhalt des im ersten Argument übergebenen Markup-Befehls in +% einer Gruppe ein temporäres Makro expandiert und als zweites Argument für die +% Weiterverarbeitung genutzt. +% \begin{macrocode} + \begingroup% + \Markup@Gobble*% + \protected@edef\tud@reserved{% + \noexpand\endgroup% + \def\noexpand\tud@reserved{#1}% + }% + \tud@reserved% + \eaddto@hook\tud@toks@{\expandafter{\tud@reserved}}% +% \end{macrocode} +% Es folgen gegebenenfalls die optionalen Argument |=|\meta{Wert}|=| sowie +% \oarg{Ausgabesuffix}~-- falls diese angegeben wurden. +% \begin{macrocode} + \IfValueT{#2}{\addto@hook\tud@toks@{=#2=}}% + \IfValueT{#3}{\addto@hook\tud@toks@{[#3]}}% +% \end{macrocode} +% Erfolgt gerade eine Deklaration, wird mit dem Schalter \cs{if@openindex} +% eigentlich unterschieden, ob ein öffnender oder ein schließender Indexeintrag +% erzeugt werden soll. Dieser wird mit \cs{Process@@Index} erstellt. Um den +% schließenden Indexeintrag zu erzeugen, ist die Ausführung des Hauptargumentes +% der Deklarationsumgebung am Ende dieser notwendig. Dabei soll allerdings das +% Markup nicht noch ein weiteres Mal ausgegeben werden. Deshalb wird der +% Schalter hier genutzt, um lediglich zu Beginn einer Deklaration das Markup +% auszuführen. Dabei Angaben für eine |'|\meta{Referenzvariante}|'| nicht +% erlaubt. +% \begin{macrocode} +%<*class> + \if@tud@declare% + \if@openindex% + \IfValueT{#6}{% + \ClassWarning{tudscrmanual}{% + It is not possible to use any cross-reference\MessageBreak% + shorthand like '#6' within the arguments of\MessageBreak% + the environment `Declaration'% + }% + }% +% \end{macrocode} +% Für ein eventuell notwendiges Debugging, wird \cs{Process@@MarkupDeclare} mit +% seinen Argumenten ggf. in das Log-File geschrieben. +% \begin{macrocode} + \tud@trace@markup{declare}{\the\tud@toks@}% + \else% + \tud@toks@{\relax}% + \fi% +% \end{macrocode} +% Findet der Auszeichnungsbefehl außerhalb einer Umgebung für Deklarationen +% Verwendung, werden die optionalen Argumente für einen CTAN-Link +% |<|\meta{CTAN-Paketname}|>| sowie die Formatierung des Querverweise +% |'|\meta{Referenzvariante}|'| hinzugefügt~-- falls vorhanden. Dies geschieht +% jedoch nur, wenn das Markup nicht innerhalb eines Index erfolgt, da hier +% URL-Hyperlinks und formatierte Querverweise unerwünscht sind. Mit der Angabe +% eines leeren Argumentes |<>| wird gar kein Hyperlink erstellt. +% \begin{macrocode} + \else% +%</class> + \if@tud@index\else% + \IfValueT{#5}{% + \ifxblank{#5}{}{\addto@hook\tud@toks@{<http://www.ctan.org/pkg/#5>}}% + }% + \IfValueT{#6}{\addto@hook\tud@toks@{'#6'}}% + \fi% +%<*class> +% \end{macrocode} +% Auch hier wird ggf. ein Debug-Eintrag ins Log-File geschrieben. +% \begin{macrocode} + \tud@trace@markup{output}{\the\tud@toks@}% + \fi% +% \end{macrocode} +% Ganz zum Schluss wird noch für beide Fälle geprüft, ob \parg{Bundleelement} +% angegeben wurde. Ist dies der Fall, wird zum einen das \meta{Bundleelement} +% zur Überprüfung ggf. in das Log-File geschrieben, zum anderen wird geprüft, +% ob für das \meta{Element} überhaupt ein Link definiert wurde, der verwendet +% werden soll. Ist dies nicht der Fall, wird eine Warnung ausgegeben. Dies ist +% möglich, da durch die automatische Labelgenerierung normalerweise alle nicht +% existierenden Labels mit \meta{Bundlepräfix} auf \cs{tud@bdl@dftl} verweisen +% müssten. Für die wenigen Fälle, in denen gezielt auf einen Querverweis +% verzichtet werden soll, kann ein leeres Argument \parg{} angegeben werden. +% \begin{macrocode} + \if@tud@index\else% + \IfValueT{#4}{% + \ifxblank{#4}{}{% + \tud@trace@bdl@add{#4}% + \ifstr{#6}{none}{}{% + \tud@if@lbl@exists{\tud@lbl@tmp}{}{% + \ClassWarning{tudscrmanual}{% + No existing label \tud@lbl@tmp\space for #4% + }% + }% + }% + }% + }% + \fi% +% \end{macrocode} +% Nun erfolgt mit \cs{Process@@MarkupDeclare} bzw. \cs{Process@@MarkupInline} +% die Ausführung der eigentlichen Auszeichnung. +% \begin{macrocode} +%</class> + \the\tud@toks@% +} +% \end{macrocode} +% \end{macro}^^A \Markup@@Suppress +% \end{macro}^^A \Markup@Suppress +% \end{macro}^^A \Process@Markup +% \begin{macro}{\Process@@MarkupDeclare} +% \changes{v2.05}{2015/11/05}{neu}^^A +% Mit \cs{Process@@MarkupDeclare} wird die formatierte Ausgabe der Deklaration +% realisiert. Wie diese genau gestaltet ist, wird durch \cs{tud@declare@num} +% bestimmt. Folgende Werte sind möglich: +% \begin{description} +% \item[\val{0}:] Ausgabe von Markup, Erzeugen eines Labels +% \item[\val{1}:] Ausgabe von Markup, kein Label +% \item[\val{2}:] keine Ausgabe, aber Erzeugen eines Labels +% \item[\val{3}:] keine Ausgabe, Erzeugen eines nach oben verschobenen Labels +% \end{description} +% Normalerweise kommt die erste Variante zum Einsatz. Die zweite Variante wird +% genutzt, wenn mit mit der Umgebung \env{Obsolete} zwar eine Ausgabe aber kein +% Label erstellt werden soll. Dies wird verwendet, um bei der Beschreibung +% veralteter Werte oder Parameter diese im Kontext ihrer Option oder Umgebung +% bzw. ihres Befehls anzugeben. +% +% Die dritte Version kommt bei Erklärungen mit der Umgebung \env{Declaration*} +% zum Einsatz, welche im Fließtext verwendet wird und kein Markup, wohl aber +% eine Label für das beschriebene Element erzeugt werden soll. Für die vierte +% Variante, welche die Umgebung \env{Bundle*} betrifft, gilt dies im Prinzip +% gleichermaßen. Allerdings wird diese Umgebung zu Beginn der Deklarationen +% eines Bundleelements direkt nach einer Überschrift verwendet. Hier soll der +% erzeugte Link direkt auf der Höhe der Überschrift platziert werden. +% +% Das erste Argument enthält das zu definierende Label, gefolgt vom Element, +% welches ausgezeichnet werden soll. Die tatsächliche Ausgabe erfolgt mit dem +% Makro \cs{Markup@Output}. An dieses werden die beiden optionalen Argumente +% |=|\meta{Wert}|=| und \oarg{Ausgabesuffix} direkt weitergereicht. +% +% Vor der eigentlichen Ausführung wird mit \cs{Markup@CheckFormat} geprüft, ob +% für das auszuzeichnende Element mit \cs{Markup@SetFormat} überhaupt eine +% Ausgabeformatierung defineirt wurde. Nach der Ausgabe wird diese Formatierung +% mit \cs{Markup@ClearFormat} zurückgesetzt. +% \begin{macrocode} +%<*class> +\NewDocumentCommand\Process@@MarkupDeclare{mmd==o}{% + \Markup@CheckFormat% + \ifcase\tud@declare@num\relax% + \tudhyperdef{#1}% + \Markup@Output{#2}=#3=[#4]% + \or% + \Markup@Output{#2}=#3=[#4]% + \or% + \tudhyperdef{#1}% + \or% + \tudhyperdef*{#1}% + \def\@tempa##1:##2:##3\@nil{\tudhyperdef*{##3:##2:##3}}% + \@tempa#1\@nil% + \fi% + \Markup@ClearFormat% +} +%</class> +% \end{macrocode} +% \end{macro}^^A \Process@@MarkupDeclare +% \begin{macro}{\Process@@MarkupInline} +% \changes{v2.05}{2015/11/05}{neu}^^A +% Mit \cs{Process@@MarkupInline} wird die formatierte Ausgabe außerhalb der +% Deklarationsumgebungen umgesetzt. Die ersten vier Argument entsprechen denen +% des Befehls \cs{Process@@MarkupDeclare} und werden bis auf das Label ebenso an +% \cs{Markup@Output} übergeben, nachdem mit dem Befehl \cs{Markup@CheckFormat} +% auf eine existierende Markup-Definition geprüft wurde. +% \ToDo{% +% Hyperlinks auf erläuterte Element innerhalb der Umgenung \env{Declaration} +% unterbinden? Könnte \cs{tud@declaration@list} genutzt werden?% +% }[v2.07]% +% \begin{macrocode} +\NewDocumentCommand\Process@@MarkupInline{mmd==od<>d''}{% + \Markup@CheckFormat% +% \end{macrocode} +% Um die aktuelle Definiton der temporären Makros nicht zu ändern, erfolgt die +% formatierte Ausgabe in einer Gruppe. Dabei wird in \cs{@tempc} die minimale +% Variante gesichert. +% \begin{macrocode} + \begingroup% + \def\@tempc{\Markup@Output{#2}=#3=[#4]}% +% \end{macrocode} +% Danach wird eine Fallunterscheidung anhand des im ersten Argument übergebenen +% Labels getroffen. Existiert dieses, soll das Element als Hyperlink ausgegeben +% werden. Die Definition dafür wird in \cs{@tempa} gespeichert. +% \begin{macrocode} +%<*class> + \tud@if@lbl@exists{#1}{% + \def\@tempa{\hyperref{}{\tud@manualname}{#1}{\@tempc}}% +% \end{macrocode} +% Anschließend wird \cs{@tempb} ggf. für den erweiterten Querverweis verwendet. +% Wurde ein Format für den Querverweis gesetzt, muss dieses validiert werden. +% Gültige Kürzel sind |'|\val{auto}|'|, |'|\val{page}|'| und |'|\val{full}|'|. +% Damit werden die erzeugten Querverweise um den Gliederungsabschnitt, die +% Seite oder beides ergänzt. Außerdem kann mit |'|\val{none}|'| der Hyperlink +% komplett unterbunden werden. Für den Befehl \cs{Package} kann mit zusätzlich +% |'|\val{url}|'| noch der CTAN-Link forciert werden, auch wenn eigentlich ein +% Label für das Paket existiert. +% \begin{macrocode} + \let\@tempb\relax% + \IfValueT{#6}{% + \def\@tempb{% +%<*class> + \ClassWarning{tudscrmanual}% +%</class> +%<*package> + \PackageWarning{tudscrtutorial}% +%</package> + {% + You've used the unknown cross-reference\MessageBreak% + shorthand '#6'. Only 'auto', 'page' and 'full'\MessageBreak% + as well as 'none' \IfValueT{#5}{or 'url' }are valid% + }% + }% + \ifstr{#6}{auto}{\def\@tempb{ in \autoref{#1}}}{% + \ifstr{#6}{page}{\def\@tempb{ \vpageref{#1}}}{% + \ifstr{#6}{ppage}{\def\@tempb{ \reftextfaraway{#1}}}{% + \ifstr{#6}{full}{\def\@tempb{ in \fullref{#1}}}{% + \ifstr{#6}{none}{\let\@tempa\@tempc\let\@tempb\relax}{}}}}}% + \IfValueT{#5}{% + \ifstr{#6}{url}{\def\@tempa{\href{#5}{\@tempc}}\let\@tempb\relax}{}% + }% + }% + }{% +%</class> +% \end{macrocode} +% Existiert kein Label, so wird einfach die minimale Markup-Variante verwendet. +% Für Pakete wird ein CTAN-Link erzeugt. +% \begin{macrocode} + \let\@tempa\@tempc% + \IfValueT{#5}{\def\@tempa{\href{#5}{\@tempc}}}% +% \end{macrocode} +% Ein Querverweis kann logischerweise nicht erstellt werden. Wurde dennoch im +% letzten optionalen Argument eine |'|\meta{Referenzvariante}|'| für den +% Querverweis angegeben, wird eine Warnung erzeugt. +% \begin{macrocode} + \let\@tempb\relax% + \IfValueT{#6}{% + \ifstr{#6}{none}{\let\@tempa\@tempc}{% +%<package> \ifstr{#6}{manual}{\def\@tempa{\tudhyperref{#1}{\@tempc}}}{% + \def\@tempb{% +%<*class> + \ClassWarning{tudscrmanual}% +%</class> +%<*package> + \PackageWarning{tudscrtutorial}% +%</package> + {% +%<*class> + Label #1\MessageBreak% + is missing, no cross-reference created% +%</class> +%<*package> + You've used the unknown cross-reference\MessageBreak% + shorthand '#6'. Only 'none' and 'manual'\MessageBreak% + are valid% +%</package> + }% + }% +%<package> }% + }% + }% +% \end{macrocode} +% Um im Zweifel nach allen fehlenden Labels im Log-File prüfen zu können, gibt +% es den passenden Debug-Befehl. +% \begin{macrocode} +%<*class> + \tud@trace@lbl@missing@add{#1}% + }% +%</class> +% \end{macrocode} +% Ganz zum Schluss erfolgt die Ausgabe als Hyperlink mit optional erweitertem +% Querverweis nicht, wenn gerade eine Überschrift gesetzt wird. +% \begin{macrocode} + \ifdisposition{\@tempc}{\@tempa\@tempb}% +% \end{macrocode} +% Zum Schluss wird die Formatierung mit \cs{Markup@ClearFormat} zurückgesetzt. +% \begin{macrocode} + \endgroup% + \Markup@ClearFormat% +} +% \end{macrocode} +% \end{macro}^^A \Process@@MarkupInline +% \begin{macro}{\Markup@Output} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\Markup@@Output} +% \changes{v2.05}{2015/11/05}{neu}^^A +% Der Befehl \cs{Markup@Output} wird für die formatierte Markup-Ausgabe von den +% beiden Makros \cs{Process@@MarkupDeclare} sowie \cs{Process@@MarkupInline} +% aufgerufen. Das erste Argument enthält dabei das auszuzeichnende Element. +% Dabei ist die Besonderheit des Makros \cs{Key}\marg{Makro}\marg{Parameter} zu +% beachten, dessen beiden Argumente hier in der Form \marg{Makro!Parameter} +% übergeben werden. Deshalb wird das erste Argument mit dem Argumentprozessor +% \cs{SplitArgument}|{1}{!}| getrennt und dann weiter verarbeitet. +% \begin{macrocode} +\NewDocumentCommand\Markup@Output{>{\SplitArgument{1}{!}}mr==r[]}{% + \Markup@@Output#1=#2=[#3]% +} +% \end{macrocode} +% Anschließend wird entweder \cs{Markup@Declare} oder \cs{Markup@Inline} +% aufgerufen~-- abermals abhängig vom Schalter \cs{if@tud@declare}. Auch hier +% wird für den Befehlsaufruf mit dem dazugehörigen Argument zur Vereinfachung +% ein Token-Register verwendet. +% \begin{macrocode} +\NewDocumentCommand\Markup@@Output{mmr==r[]}{% +%<*class> + \if@tud@declare% + \tud@toks@{\Markup@Declare}% + \else% +%</class> + \tud@toks@{\Markup@Inline}% +%<*class> + \fi% +%</class> +% \end{macrocode} +% Ist das aktuelle Element \cs{Key} wird nur das zweite Argument ausgegeben. +% Das erste wird lediglich für Label und Indexeintrag benötigt. +% \begin{macrocode} + \IfValueTF{#2}{% + \def\@tempa{#2}% + }{% + \def\@tempa{#1}% + }% +% \end{macrocode} +% Die beiden optionalen Argumente werden ggf. in der gleichen Formatierung +% ausgegeben. +% \begin{macrocode} + \IfValueT{#3}{\appto\@tempa{=#3}}% + \IfValueT{#4}{\appto\@tempa{#4}}% + \eaddto@hook\tud@toks@{\expandafter{\@tempa}}% + \the\tud@toks@% +} +% \end{macrocode} +% \end{macro}^^A \Markup@@Output +% \end{macro}^^A \Markup@Output +% \begin{macro}{\Markup@Inline} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\Markup@Declare} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\Markup@@Declare} +% \changes{v2.05}{2015/11/05}{neu}^^A +% Die Ausgabe selbst ist alles andere als spektakulär. Die zur Formatierung +% verwendeten Makros \cs{Markup@Format} und \cs{Markup@Suffix} werden durch +% \cs{Markup@SetFormat} für jedes Markup-Element individuell definiert. +% \begin{macrocode} +\newcommand*\Markup@Inline[1]{\mbox{\Markup@Format{#1}}} +%<*class> +\newcommand*\Markup@Declare{} +\newcommand*\Markup@@Declare[1]{\Markup@Format{#1}\Markup@Suffix} +%</class> +% \end{macrocode} +% \end{macro}^^A \Markup@@Declare +% \end{macro}^^A \Markup@Declare +% \end{macro}^^A \Markup@Inline +% \begin{macro}{\Markup@SetFormat} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\Markup@CheckFormat} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\Markup@ClearFormat} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\Markup@Format} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\Markup@Suffix} +% \changes{v2.05}{2015/11/05}{neu}^^A +% Der Befehl \cs{Markup@SetFormat} setzt das gewünschte Format für die jeweilge +% Ausgabe. Dieses wird im ersten Argument angegeben. Das ordinäre optionale +% Argument kann genutzt werden, wenn bei der Deklaration noch eine genauere +% Beschreibung oder Spezifizierung erscheinen soll, beispielsweise etwas wie +% \enquote{Umgebung} oder \enquote{Parameter}. Mit dem optionalen Argument in +% runden Klammern wird es möglich, die Definition von \cs{Markup@Declare}, die +% ohne eine Angabe der von \cs{Markup@@Declare} entspricht, zu ändern. Dies +% wird insbesondere von \cs{Environment} genutzt, um bei der Deklaration eine +% Tabelle zu erzeugen. +% \begin{macrocode} +\newcommand*\Markup@Format{} +\undef\Markup@Format +\newcommand*\Markup@Suffix{} +\NewDocumentCommand\Markup@SetFormat{omod()}{% +% \end{macrocode} +% Außerdem ist noch eine weitere Besonderheit zu beachten. Sollte gerade eine +% Überschrift gesetzt werden, wird das Hauptargument nicht formatiert sondern +% lediglich mit \cs{tud@sec@format} ausgegeben. +% \begin{macrocode} + \def\Markup@Format##1{% + \def\tud@res@a{#2}% + \tud@ifdin{\let\tud@res@a\tud@sec@format}{}% + \begingroup\tud@res@a{\IfValueT{#1}{#1}##1}\endgroup% + }% + \IfValueT{#3}{\def\Markup@Suffix{\suffix{#3}}}% +%<*class> + \IfValueT{#4}{\renewcommand*\Markup@Declare[1]{#4\Markup@Suffix}}% +%</class> +} +% \end{macrocode} +% Nach der formatierten Ausgabe wird \cs{Markup@ClearFormat} aufgerufen, um die +% aktuell definierte Formatierung zurückzusetzen und bei einem neuen Aufruf +% eines der Markup-Befehle mit \cs{Markup@CheckFormat} auf die Verwendung von +% \cs{Markup@SetFormat} prüfen zu können. +% \begin{macrocode} +\newcommand*\Markup@ClearFormat{% + \undef\Markup@Format% + \let\Markup@Declare\Markup@@Declare% + \let\Markup@Suffix\relax% +} +\Markup@ClearFormat +\newcommand*\Markup@CheckFormat{% + \ifundef\Markup@Format{% +%<*class> + \ClassError{tudscrmanual}% +%</class> +%<*package> + \PackageError{tudscrtutorial}% +%</package> + {\string\Markup@SetFormat\space unused}% + {It seems you have forgotten to use \string\Markup@SetFormat.}% + }{}% +} +% \end{macrocode} +% \end{macro}^^A \Markup@Suffix +% \end{macro}^^A \Markup@Format +% \end{macro}^^A \Markup@ClearFormat +% \end{macro}^^A \Markup@SetFormat +% \end{macro}^^A \Markup@CheckFormat +% \begin{macro}{\tud@nonchangecase} +% \changes{v2.05}{2015/11/20}{neu}^^A +% \begin{macro}{\tud@x@textcase@uclcnotmath} +% Die \TUDScript-Hauptklassen definieren in Ergänzung zum Paket \pkg{textcase} +% den internen Befehl \cs{tud@x@textcase@uclcnotmath}, womit die Definition von +% Makros ermöglicht wird, welche von \cs{MakeTextUppercase} nicht beachtet +% werden sollen. Hierfür werden \emph{alle} Markup-Befehle der Liste zum +% Ignorieren hinzugefügt. Damit aber bei der eigentlichen Ausgabe alles in +% Majuskeln erscheint, wird für diesen Fall \cs{Markup@Format} genutzt. +% \begin{macrocode} +\ifundef{\tud@x@textcase@uclcnotmath}{}{% + \NewDocumentCommand\tud@nonchangecase{m}{% + \DeclareExpandableDocumentCommand#1{sm}{% + \IfBooleanT{##1}{\noexpand\@tud@indextrue}% + \NoCaseChange{#1{##2}}% + }% + } + \apptocmd{\tud@x@textcase@uclcnotmath}{% + \tud@nonchangecase\Application% + \tud@nonchangecase\Distribution% + \tud@nonchangecase\Engine% + \tud@nonchangecase\File% + \tud@nonchangecase\Class% + \tud@nonchangecase\Package% + \tud@nonchangecase\Option% + \tud@nonchangecase\Environment% + \tud@nonchangecase\Macro% + \tud@nonchangecase\Length% + \tud@nonchangecase\Counter% +%<*class> + \DeclareExpandableDocumentCommand\Key{smm}{% + \IfBooleanT{##1}{\noexpand\@tud@indextrue}% + \NoCaseChange{#1{##2}{##3}}% + }% + \tud@nonchangecase\Term% + \tud@nonchangecase\PageStyle% + \tud@nonchangecase\Font% + \tud@nonchangecase\Color% +%</class> + }{}{\tud@patch@wrn{tud@x@textcase@uclcnotmath}} +} +% \end{macrocode} +% \end{macro}^^A \tud@x@textcase@uclcnotmath +% \end{macro}^^A \tud@nonchangecase +% +% \subsection{Index} +% +% Hier erscheint alles, was für Erstellen und Ausgabe der einzelnen Indexe +% notwendig ist. Hierfür wird das Paket \pkg{imakeidx} in Verbindung mit +% \app{texindy} verwendet. Diese können sowohl mit dem Paket als auch mit der +% Klasse erzeugt werden. +% \begin{macrocode} +\PassOptionsToPackage{xindy,splitindex}{imakeidx} +\RequirePackage{imakeidx}[2013/07/11] +% \end{macrocode} +% Zuerst ein paar kleinere Einstellungen für das Layout\dots +% \begin{macrocode} +\indexsetup{% +%<*class> + level=\addsec,% +%</class> +%<*package> + level=\subsection*,% +%</package> + noclearpage,firstpagestyle=headings,headers={\indexname}{\indexname},% + othercode={\renewcommand*\subitem{\@idxitem\hspace*{15\p@}}}% +} +% \end{macrocode} +% \begin{environment}{theindex} +% \dots gefolgt von einem Patch für die Umgebung \env{theindex}, um unschöne +% Seitenumbrüche direkt nach Überschriften zu vermeiden. Diese treten auf, das +% das Paket \pkg{imakeidx} meiner Meinung nach die Überschriften zusammen mit +% der \env{multicols}-Umgebung falsch setzt. Der Patch sorgt dafür, dass die +% Überschriften (\cs{imki@indexlevel}|{|\cs{indexname}|}|) nicht +% vor der Umgebung sondern~-- wie für \pkg{multicol} auch dokumentiert~-- im +% optionalen Argument von \env{multicols} aufgerufen werden. +% \begin{macrocode} +\ifimki@original\else% + \CheckCommand\theindex{% + \imki@maybeaddtotoc + \imki@indexlevel{\indexname}\imki@indexheaders + \thispagestyle{\imki@firstpagestyle}% + \ifnum\imki@columns>\@ne + \columnsep \imki@columnsep + \ifx\imki@idxprologue\relax + \begin{multicols}{\imki@columns} + \else + \begin{multicols}{\imki@columns}[\imki@idxprologue] + \fi + \else + \imki@idxprologue + \fi + \global\let\imki@idxprologue\relax + \parindent\z@ + \parskip\z@ \@plus .3\p@\relax + \columnseprule \ifKV@imki@columnseprule.4\p@\else\z@\fi + \raggedright + \let\item\@idxitem + \imki@othercode% + }% + \patchcmd{\theindex}{% + \imki@indexlevel{\indexname}\imki@indexheaders% + }{% + \imki@indexheaders% + }{}{\tud@patch@wrn{theindex}}% + \patchcmd{\theindex}{% + \ifnum\imki@columns>\@ne + \columnsep \imki@columnsep + \ifx\imki@idxprologue\relax + \begin{multicols}{\imki@columns} + \else + \begin{multicols}{\imki@columns}[\imki@idxprologue] + \fi + \else + \imki@idxprologue + \fi + }{% + \ifnum\imki@columns>\@ne\relax% + \columnsep \imki@columnsep% + \ifx\imki@idxprologue\relax% + \begin{multicols}{\imki@columns}[\imki@indexlevel{\indexname}]% + \else% + \begin{multicols}{\imki@columns}[% + \imki@indexlevel{\indexname}% + \imki@idxprologue% + ]% + \fi% + \else% + \imki@indexlevel{\indexname}\imki@idxprologue% + \fi% + }{}{\tud@patch@wrn{theindex}}% +\fi% +% \end{macrocode} +% \end{environment}^^A theindex +% \begin{macro}{\makexdyindex} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Um die einzelnen Indexe erstellen zu können, wird das Makro \cs{makexdyindex} +% definiert. Die Sternversion dieses Befehle erstellt dabei neben dem normalen +% Spezialindex einen weiteren, welcher explizit für Deklarationen genutzt wird. +% Dieser wird anschließen als erstes an \app{texindy} weitergereicht, um die +% richtige Formatierung der einzelnen Einträge gewährleisten zu können. Erst +% danach wird die Datei mit den normalen Einträgen verarbeitet. Siehe hierzu +% auch \cs{Process@@Index}. +% \begin{macrocode} +\NewDocumentCommand\makexdyindex{s o m !o}{% + \let\@tempb\@empty% +%<*class> + \IfBooleanT{#1}{% + \def\@tempc{\jobname-#4-declare.idx}% + \makeindex[name={#4-declare}]% + \IfFileExists{\@tempc}{% + \edef\@tempb{-o \jobname-#4.ind \@tempc}% + }{% + \ClassWarning{tudscrmanual}{File \@tempc\space not found}% + }% + }% +%</class> + \protected@edef\@tempa{% + title={#3},% + columnsep=\noexpand\f@size\noexpand\p@,% + \IfValueTF{#4}{% + name={#4},% + options={-M \@currname-ind.xdy -L german-din -t \jobname-#4.xlg \@tempb},% + }{% + options={-M \@currname-ind.xdy -L german-din -t \jobname.xlg},% + }% + \IfValueT{#2}{#2}% + }% + \expandafter\makeindex\expandafter[\@tempa]% +} +% \end{macrocode} +% \end{macro}^^A \makexdyindex +% Nun können mit \cs{makexdyindex} die einzelnen Indexe erstellt werden. +% \begin{macrocode} +\makexdyindex{Allgemeiner Index} +\makexdyindex*{Klassen- und Paketoptionen}[options] +\makexdyindex*{Befehle und Umgebungen mit zugeh\"origen Parametern}[macros] +%<*class> +\makexdyindex*{Sprachabh\"angige Bezeichner}[terms] +\makexdyindex*{Seitenstile, Schriftelemente und Farben}[elements] +%</class> +\makexdyindex{L\"angen und Z\"ahler}[misc] +\makexdyindex*{Klassen, Pakete und Dateien}[files] +%<*class> +\makexdyindex[columns=1]{\"Anderungsliste}[changelog] +%</class> +\undef\makexdyindex +% \end{macrocode} +% \begin{macro}{\if@tud@index} +% \changes{v2.05}{2015/11/05}{neu}^^A +% Dieser Schalter wird zwei unterschiedliche Aufgaben verwendet. Zum einen wird +% er bei der Ausgabe von Verzeichnissen auf \val{true} gesetzt, um das Setzen +% von Indexeinträgen durch Markup-Befehle in den Verzeichnissen selbst zu +% unterbinden. Weiterhin verhindert der aktivierte Schalter bei der Ausführung +% von \cs{Process@Markup} das Erstellen von erweiterten Querverweisen sowie das +% Setzen von CTAN-Links bei Paketen (\cs{Package}), was weder in Verzeichnissen +% noch im Index erwünscht ist, weshalb vom Makro \cs{@printindex} ebenfalls +% \cs{@tud@indextrue} gesetzt wird. +% \begin{macrocode} +\newif\if@tud@index +\addtoeachtocfile{\protect\@tud@indextrue} +% \end{macrocode} +% \end{macro}^^A \if@tud@index +% +% \subsubsection{Formatierung von Indexeinträgen} +% +% \begin{macro}{\tud@idx@get} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\tud@idx@key} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\tud@idx@fmt} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\tud@idx@val} +% \changes{v2.05}{2015/11/05}{neu}^^A +% \begin{macro}{\tud@idx@bdl} +% \changes{v2.05}{2015/11/05}{neu}^^A +% Mit dem Makro \cs{tud@idx@get} wird die Formatierung eines Indexeintrags für +% einen Markup-Befehl realisiert. Für das Sortieren der Indexeinträge kommt +% \app{texindy} zum Einsatz. Um die Indexeinträge wie gewünscht zu Formatieren, +% gibt es zwei Möglichkeit. +% +% Bei der ersten Variante würde der Indexeintrag einfach direkt mit den +% Markup-Befehlen erstellt und in der \app{texindy}-Stildatei wird für alle +% Auszeichnungsbefehle die passende |merge-rule| erstellt, um die korrekte +% Sortierung zu gewährleisten. Tatsächlich war in einer früheren Version genau +% das der Ansatz. Allerdings werden die manuell erstellten RegExp-Regeln durch +% \hrfn{http://sourceforge.net/p/xindy/bugs/22/}{\app{texindy} nicht korrekt} +% genutzt werden, weshalb der Ansatz verworfen wurde. +% +% Damit das Sortieren verlässlich funktioniert, werden die Einträge für den +% Index deshalb in der gewohnten Syntax von \app{makeindex} in der Form +% \meta{Schlüsselwort}|@|\meta{Markup} erstellt. Diese Syntax kann auch mit +% \app{texindy} genutzt werden. +% +% An \cs{tud@idx@get} werden vier obligatorische gefolgt von vier optionalen +% Argumenten übergeben. Die ersten beiden Argumente sind die Makros, in welche +% \meta{Schlüsselwort}~-- für gewöhnlich \cs{tud@idx@key}~-- sowie die +% Formatierung \meta{Markup}~-- normalerweise \cs{tud@idx@fmt}~-- expandiert +% werden. Mit dem Makro im dritten Argument wird es möglich, Untereinträge zu +% einem \meta{Schlüsselwort} für beispielsweise Parameter von Umgebungen oder +% Befehlen (\cs{Key}) sowie spezielle Schlüsselwerte von Optionen zu erzeugen. +% Dabei wird vor der Erstellung des Untereintrages der direkt zuvor generierte +% Indexhaupteintrag ins dritte Argument~-- normalerweise \cs{tud@idx@val}~-- +% gesichert. Das vierte und letzte obligatorische Argument enthält schließlich +% den eigentlichen Markup-Befehl, für welchen der Indexeintrag erzeugt werden +% soll. +% +% Daran schließen sich vier optionale Argumente an, mit denen die Formatierung +% des Indexeintrags differenziert werden kann. Das erste optionale Argument +% |=|\meta{Wert}|=| kann wie bereits gewohnt für das Hinzufügen eines +% Schlüsselwertes genutzt werden. Das zweite, ordinäre optionale Argument +% \oarg{Anmerkung} fügt dem Eintrag in den Index eine zusätzliche Anmerkung +% hinzu. Soll der Indexeintrag für ein spezifisches Paket oder eine Klasse aus +% dem \TUDScript-Bundle erstellt werden, wird das optionale Argument in runden +% Klammern \parg{\string\Class\marg{Klasse}/\string\Package\marg{Paket}} für +% einen Verweis auf das \parg{Bundleelement} verwendet, der in \cs{@idxbundle} +% gespeichert wird. Das Argument \verb=|=\meta{Indexmarkup}\verb=|= wird bei +% Deklarationen zur Unterdrückung von Untereinträgen verwendet. +% Der vollständige Funktionsaufruf lautet: +% \newline\begingroup\scriptsize +% \cs{tud@idx@get}\cs{tud@idx@key}\cs{tud@idx@fmt}\ignorespaces% +% \cs{tud@idx@val}\marg{Elem.}|=|\meta{Wert}|=|\oarg{Anm.}\ignorespaces% +% \parg{Bundleelem.}\verb=|=\meta{Indexmark.}\verb=|=\ignorespaces% +% \endgroup +% \begin{macrocode} +\newcommand*\tud@idx@key{} +\newcommand*\tud@idx@fmt{} +\newcommand*\tud@idx@val{} +\newcommand*\tud@idx@bdl{} +\NewDocumentCommand\tud@idx@get{smmmmr==r[]r()d||}{% +% \end{macrocode} +% Die Änderungen an allerhand temporären Makros sollen lokal bleibens. +% \begin{macrocode} + \begingroup% +% \end{macrocode} +% In einer weiteren Gruppe wird der Markup-Befehl des vierten obligatorischen +% Arguments ausgewertet. Es wird eine Fallunterschiedung durchgeführt, ob es +% sich dabei um einen Parameter (\cs{Key}) handelt oder nicht. Ist dies der +% Fall, wird für diesen Parameter der hier nachfolgend formatierte Indexeintrag +% als Untereintrag verwendet. Dafür wird zuvor ein Haupteintrag aus dem ersten +% Argument von \cs{Key} generiert und in das dritte obligatorische Argument +% gespeichert (\cs{tud@idx@val}). +% \begin{macrocode} + \begingroup% +%<*class> + \let#4\@empty% + \in@{\Key}{#5}% +% \end{macrocode} +% Um den Haupteintrag zu extrahieren, wird mit \cs{Markup@Suppress} die Ausgabe +% des Markups deaktiviert und das erste Argument von \cs{Key} ausgeführt. Dies +% führt über \cs{Process@Index} zum rekursiven Aufruf von \cs{tud@idx@get}. Als +% Ergebnis sind im zweiten und dritten Argument~-- sprich in \cs{tud@idx@key} +% und \cs{tud@idx@fmt}~-- \meta{Markup} und \meta{Schlüsselwort} für den +% Elterneintrag enthalten. Diese werden in das vierte Argument (\cs{idxentry}) +% gespeichert. +% \begin{macrocode} + \ifin@% + \Markup@Suppress% + \let\Key\@firstoftwo% + #5% +% \end{macrocode} +% Da der Inhalt des vierten Arguments am Ende der Gruppe expandiert wird, wird +% mit \cs{expandonce} dafür gesorgt, dass die Expansion nur einmalig erfolgt. +% Zu beachten ist außerdem, dass der Hauptindexeintrag bereits in der Form +% \meta{Schlüsselwort}|@|\meta{Markup}|!| zusammengefügt wird. Die Sternversion +% wird für die Änderungsnotizen verwendet. Für diese wird eine kleine Anmerkung +% im Haupteintrag ergänzt. +% \begin{macrocode} + \let\@tempa\@empty% + \IfBooleanT{#1}{\def\@tempa{: Parameter angepasst}}% + \def#4{% + \expandonce#2\expandonce\@tempa{}@% + \expandonce#3\expandonce\@tempa{}!% + }% + \fi% +%</class> +% \end{macrocode} +% Nachdem ein möglicher Haupteintrag für Parameter erzeugt wurde, folgt nun +% der formatierte Indexeintrag für das aktuelle Markup-Element. Um diesen zu +% erstellen, wird für \meta{Schlüsselwort} zunächst nur der Inhalt des +% Hauptargumentes benötigt. Dieser wird hier in das zweite Argument +% expandiert, der ggf. erzeugte Haupteintrag in das vierte. Für \cs{Key} ist +% hier nur noch das zweite Argument relevant. +% \begin{macrocode} + \Markup@Gobble% +%<class> \let\Key\@secondoftwo% + \edef\tud@reserved{% + \noexpand\endgroup% + \def\noexpand#2{#5}% +%<class> \def\noexpand#4{#4}% + }% + \tud@reserved% +% \end{macrocode} +% Die Auszeichnung für den Indexeintrag besteht in erster Linie aus dem +% Markup-Befehl selbst. Damit ein |@|"~Zeichen beispielsweise in einem +% Makronamen korrekt verarbeitet wird, wird dieses im Stil von \app{makeindex} +% mit |"| maskiert. +% \begin{macrocode} + \def#3{#5}% + \tud@replace#2{@}{"@}% + \tud@replace#3{@}{"@}% +% \end{macrocode} +% In \cs{@idxbundle} wird ggf. das Paket oder die Klasse gespeichert, für die +% der aktuelle Eintrag erzeugt werden soll. Eine explizite Angabe wird in jedem +% Fall genutzt,\dots +% \begin{macrocode} + \let\tud@idx@bdl\tud@bdl@dflt% + \IfValueTF{#8}{% + \def\tud@idx@bdl{#8}% + }{% +% \end{macrocode} +% \dots eine implizite nur, wenn auch tatsächlich das passende Label existiert, +% da sonst mit Sicherheit falsche Einträge im Index erscheinen würden. +% \begin{macrocode} +%<*class> + \tud@if@bdl{% + \tud@if@lbl@exists{\tud@bdl@curr:#5}{% + \edef\tud@idx@bdl{\expandonce\tud@bdl@curr}% +% \end{macrocode} +% Sollte der Eintrag selbst dem Suffix für Paket oder Klasse entsprechen, wird +% dieser ignoriert. +% \begin{macrocode} + \def\tud@reserved{#5}% + \ifx\tud@reserved\tud@idx@bdl% + \let\tud@idx@bdl\tud@bdl@dflt% + \fi% + }{}% + }{}% +%</class> + }% +% \end{macrocode} +% Nachfolgend wird für den zu erzeugenden Indexeintrag die Zugehörigkeit des +% aktuellen Elements zu einem Paket oder einer Klasse aus dem \TUDScript-Bundle +% durch das Anhängen des jeweiligen \TUDScript-Bundle-Elements signalisiert. +% Dabei werden für die Anpassung von Schlüssel und Formatierung des Eintrags +% die temporären Makros \cs{@tempa}~(Schlüssel) und \cs{@tempb}~(Formatierung) +% gespeichert. In \cs{@tempc} wird der Inhalt von \cs{@tempb} zwischenzeitlich +% zur späteren Verwendung gesichert. +% \begin{macrocode} + \let\@tempa\@empty% + \let\@tempb\@empty% + \let\@tempc\@empty% +% \end{macrocode} +% Der temporäre Schalter \cs{@tempswa} wird genutzt, um das Hinzufügen der +% Ergänzungen zu steuern. Diese sollen nur für Elemente, welche nicht zu den +% Hauptklassen gehören, erfolgen. +% \begin{macrocode} + \@tempswatrue% + \ifx\tud@idx@bdl\tud@bdl@dflt% + \@tempswafalse% +% \end{macrocode} +% Ebenso werden die Anmerkungen für \cs{Key}-Elemente unterdrückt, da diese +% sowieso als Untereintrag erzeugt werden. Einträge in der Änderungsliste +% werden ohnehin separat für jedes \TUDScript-Bundle-Element ausgegeben. In +% jedem Fall ist jedoch Formatierung beim Markup für das Erzeugen des richtigen +% Querverweises notwendig und wird in \cs{@tempb} und \cs{@tempc} abgelegt. +% \begin{macrocode} + \else% +%<class> \in@{\Key}{#5}\ifin@\@tempswafalse\fi% + \IfBooleanT{#1}{\@tempswafalse}% + \edef\@tempb{(\expandonce\tud@idx@bdl)}% + \fi% + \let\@tempc\@tempb% +% \end{macrocode} +% Der Indexeintrag kann zur besseren Kenntnisnahme außerdem standardmäßig mit +% einer Beschreibung versehen werden. +% \begin{macrocode} + \IfValueT{#7}{% + \appto\@tempa{ #7}% + \appto\@tempb{\suffix{#7}}% + }% +% \end{macrocode} +% Wird die Anmerkung gesetzt, ist für den Schlüssel nur der Inhalt des in +% \cs{@idxbundle} gesicherten Markup-Befehls relevant. Dieser wird in der +% folgenden Gruppe extrahiert und \cs{@tempa} angehangen. Für die Formatierung +% bleibt das Markup erhalten und wird \cs{tempb} hinzugefügt. +% \begin{macrocode} + \if@tempswa% + \begingroup% + \Markup@Gobble% + \edef\tud@reserved{% + \noexpand\endgroup% + \noexpand\appto\noexpand\@tempa{ \tud@idx@bdl}% + }% + \tud@reserved% + \eappto\@tempb{\suffix{\expandonce\tud@idx@bdl}}% + \fi% +% \end{macrocode} +% Sollte mit |=|\meta{Wert}|=| ein spezieller Schlüsselwert angegeben worden +% sein, wird für diesen normalerweise ein separater Untereintrag erstellt. Der +% Schalter \cs{@tempswa} wird genutzt, um das Erzeugen dieses Untereintrages im +% Zweifel zu unterdrücken und diesen stattdessen als normalen Eintrag zu +% setzen. Dies ist zum einen bei Deklarationen und zum anderen in der +% Änderungsliste notwendig. Außerdem kann dies auch mit der Angabe von +% \val{default} als Indexargument erzwungen werden. +% \begin{macrocode} + \@tempswafalse% + \IfBooleanT{#1}{\@tempswatrue}% + \IfValueT{#9}{\ifstr{#9}{declare}{\@tempswatrue}{}}% + \IfValueT{#9}{\ifstr{#9}{default}{\@tempswatrue}{}}% +% \end{macrocode} +% In diesem Fall werden die Ergänzungen für Schlüssel und Formatierung ggf. um +% die speziellen Schlüsselwerte für das Element ergänzt. +% \begin{macrocode} + \if@tempswa% + \protected@eappto#2{\expandonce\@tempa}% + \tud@doifPValue{#6}{\noexpand\appto\noexpand#2{=#6}}% + \protected@eappto#3{\IfValueT{#6}{=#6=}\expandonce\@tempb}% +% \end{macrocode} +% Andernfalls wird geprüft, ob ein verwertbarer Schlüsselwert angegeben wurde. +% \begin{macrocode} + \else% + \tud@doifPValue{#6}{\noexpand\@tempswatrue}% +% \end{macrocode} +% Ist dies der Fall, wird aus den bisherigen Eingaben der Haupteintrag und +% daran anschließend der dazugehörige Untereintrag erstellt\dots +% \begin{macrocode} + \if@tempswa% + \eappto#4{% + \expandonce#2\expandonce\@tempa{}@% + \expandonce#3\expandonce\@tempb{}!% + }% + \appto#2{=#6}% + \appto#3{=#6=}% + \protected@eappto#3{\expandonce\@tempc}% +% \end{macrocode} +% \dots andernfalls bleibt es bei einem normalem Eintrag in den Index. +% \begin{macrocode} + \else% + \protected@eappto#2{\expandonce\@tempa}% + \protected@eappto#3{\expandonce\@tempb}% + \fi% + \fi% +% \end{macrocode} +% Die Erzeugung eines formatierten Indexeintrages ist beendet, das Resultat +% wird nach der letzten Gruppe definiert. +% \begin{macrocode} + \let\emph\@firstofone% + \protected@edef\tud@reserved{% + \noexpand\endgroup% + \def\noexpand#2{#2}% + \def\noexpand#3{#3}% + \def\noexpand#4{#4}% + }% + \tud@reserved% +} +% \end{macrocode} +% \end{macro}^^A \tud@idx@bdl +% \end{macro}^^A \tud@idx@val +% \end{macro}^^A \tud@idx@fmt +% \end{macro}^^A \tud@idx@key +% \end{macro}^^A \tud@idx@get +% \begin{macro}{\cleversee} +% \changes{v2.05}{2015/11/02}{neu}^^A +% \begin{macro}{\cleverseealso} +% \changes{v2.05}{2015/11/02}{neu}^^A +% \begin{macro}{\tud@cleversee} +% \changes{v2.05}{2015/11/02}{neu}^^A +% \changes{v2.05k}{2017/03/20}{neu}^^A +% Diese Befehle dienen zum smarten Setzen von Hinweisen im Index. Existiert +% lediglich dieser Hinweis im Index, wird dieser mit dem Präfix \cs{seename} +% ausgegeben. Sind jedoch für einen Indexeintrag auch Seitenzahlen vorhanden, +% so werden diese zuerst ausgegeben, danach folgt der Querverweis mit dem +% Präfix \cs{seealsoname}. Der Befehl \cs{cleverseealso} verwendet letzteren +% Präfix in jedem Fall. +% \begin{macrocode} +\newrobustcmd*\cleversee{\tud@cleversee{\seename}} +\newrobustcmd*\cleverseealso{% +%<*class> + \ClassWarning{tudscrmanual}% +%</class> +%<*package> + \PackageWarning{tudscrtutorial}% +%</package> + {You should use `|see' instead of `|seealso'}% + \tud@cleversee{\alsoname}% +} +% \end{macrocode} +% Diese Makro übernimmt die eigentliche Arbeit. Es ist darauf angewiesen, dass +% die angegebene Seitenzahlen eines Indexeintrages erst \emph{nach} den +% Hinweisen ausgegeben und mit \cs{relax} abgeschlossen werden. Dies wird mit +% der später definierten Stildatei für \app{texindy} sichergestellt. So wird es +% möglich, dass das Makro \cs{tud@cleversee} auf alles ihm bis \cs{relax} +% nachfolgende parsen kann und abhängig davon die Ausgabe gestaltet. Das zweite +% obligatorische Argument beinhaltet dabei den Querverweis, das dritte Argument +% ist alles nachfolgende bis \cs{relax}. +% \begin{macrocode} +\newcommand*\tud@cleversee{} +\def\tud@cleversee#1#2#3\relax{% + \IfArgIsEmpty{#3}{% + \emph{#1}\space#2% + }{% +% \end{macrocode} +% Folgen im Index nach \cs{cleversee}\marg{Querverweis} noch weitere Einträge, +% so sind diese zu Beginn durch \texttt{,\textvisiblespace} getrennt. Diese +% zwei Zeichen werden mithilfe von \cs{@tempa} ignoriert. +% \begin{macrocode} + \begingroup% + \def\@tempa, ##1\@nil{##1,\space\emph{\alsoname}\space#2}% + \@tempa#3\@nil% + \endgroup% + }% +} +% \end{macrocode} +% \end{macro}^^A \tud@cleversee +% \end{macro}^^A \cleverseealso +% \end{macro}^^A \cleversee +% \begin{macro}{\seeref} +% \changes{v2.05}{2015/11/02}{neu}^^A +% \begin{macro}{\seeidx} +% Der Befehl \cs{seeref} kann anstelle von \cs{see} bzw. in der Sternversion +% statt \cs{alsosee} genutzt werden. Das Makro \cs{seeidx} verweist auf die +% Seite eines Indexes. +% \begin{macrocode} +%<*class> +\NewDocumentCommand\seeref{s m}{% + \emph{\IfBooleanTF{#1}{\alsoname}{\seename}}\space#2% +} +\newcommand*\seeidx[2]{\pageref{idx:#1}} +%</class> +% \end{macrocode} +% \end{macro}^^A \seeidx +% \end{macro}^^A \seeref +% +% \subsubsection{Erstellen von Indexeinträgen} +% +% \begin{macro}{\Process@Index} +% \changes{v2.05}{2015/11/15}{neu}^^A +% \begin{macro}{\Process@@Index} +% \changes{v2.05}{2015/11/15}{neu}^^A +% Mit \cs{Process@Index} wird geprüft, ob mit dem im zweiten obligatorischen +% Argument enthaltenen Markup-Befehl ein Indexeintrag erzeugt werden soll. +% Ein Indexeintrag kann mit der Sternversion eines Markup-Befehls explizit +% unterdrückt werden, wobei der boolesche Wert im ersten obligatorischen +% Argument an \cs{Process@Index} zu Prüfung übergeben wird. Außerdem wird für +% obsolete Deklarationen ebenso wie bei aktiviertem Schalter \cs{if@tud@index} +% kein Eintrag erstellt. In allen genannten Fällen passiert beim Aufruf von +% \cs{Process@Index} nichts, andernfalls wird \cs{Process@@Index} ausgeführt. +% +% Die auf die zwei obligatorischen Argumente folgenden optionalen sind in der +% Nomenklatur identisch zu den bisherigen Erläuterungen, der vollständige +% Funktionsaufruf lautet: +% \newline\begingroup\scriptsize +% \cs{Process@Index}\marg{Stern?}\marg{Element}\ignorespaces% +% |=|\meta{Wert}|=|\oarg{Anmerkung}\parg{Bundleelement}\ignorespaces% +% \verb=|=\meta{Indexmarkup}\verb=|=\ignorespaces% +% \endgroup +% \begin{macrocode} +\NewDocumentCommand\Process@Index{mmd==od()d||}{% + \ifboolexpr{% +%<class> bool {@tud@index} or bool {@tud@obsolete}% +%<package> bool {@tud@index}% + }{}{% + \IfBooleanTF{#1}{% + \IfValueT{#6}{% +%<*class> + \ClassWarning{tudscrmanual}% +%</class> +%<*package> + \PackageWarning{tudscrtutorial}% +%</package> + {% + You've used the starred version. No index entry\MessageBreak% + for #2 is created. The\MessageBreak% + optional argument |#6| will be ignored% + }% + }% + }{% + \Process@@Index{#2}=#3=[#4](#5)|#6|% + }% + }% +} +% \end{macrocode} +% Mit \cs{Process@@Index} erfolgt die eigentliche Erzeugung des Indexeintrages. +% \begin{macrocode} +\NewDocumentCommand\Process@@Index{mr==r[]r()r||}{% +% \end{macrocode} +% Dabei erledigt \cs{tud@idx@get} einen Großteil der Aufgabe. Mit besagtem +% Makro werden Schlüssel und Format für den gewünschten Indexeintrag erzeugt. +% Sollte optional ein spezieller |=|\meta{Wert}|=| für einen Schlüssel gegeben +% sein, so wird ggf. auch der passende Haupteintrag erstellt. +% \begin{macrocode} +%<*class> + \if@tud@declare% + \tud@idx@get\tud@idx@key\tud@idx@fmt\tud@idx@val{#1}=#2=[#3](#4)|declare|% + \else% +%</class> + \tud@idx@get\tud@idx@key\tud@idx@fmt\tud@idx@val{#1}=#2=[#3](#4)|#5|% +%<*class> + \fi% +%</class> +% \end{macrocode} +% Mit der Sternversion \cs{tud@attr@get*} wird der Zielindex für das im +% ersten Argument übergebene \marg{Element} ermittelt. +% \begin{macrocode} + \tud@attr@get*\tud@lbl@tmp{#1}% +% \end{macrocode} +% Markup-Befehle, welche in Deklarationen verwendet wurden, werden für eine +% höhere Priorisierung in einem speziellen Index angelegt, wobei hier die +% Formatierung dieses Eintrags fest vorgegeben ist. +% \begin{macrocode} +%<*class> + \if@tud@declare% + \if@openindex% + \IfValueT{#5}{% + \ClassWarning{tudscrmanual}{% + It is not possible to use any indexing format\MessageBreak% + like |#5| within the arguments of the\MessageBreak% + environments `Declaration' or `Declaration*'% + }% + }% +% \end{macrocode} +% Jetzt folgt~-- abhängig vom Schalter \cs{if@openindex}~-- der öffnende oder +% schließende Indexeintrag der Deklaration. Für den schließenden ist dabei eine +% Formatierung des Schlüssels nicht notwendig. +% \begin{macrocode} + \index[\tud@lbl@tmp-declare]{% + \tud@idx@val\tud@idx@key{}@\tud@idx@fmt|(declare% + }% + \else% + \index[\tud@lbl@tmp-declare]{\tud@idx@val\tud@idx@key|declare)}% + \fi% +% \end{macrocode} +% Für Markup-Befehle außerhalb von Deklarationsumgebungen wird ein einfacher +% Eintrag in den Index erzeugt, wobei auch im Fließtext über das Indexmarkup +% \verb=|=\val{declare}\verb=|= eine Quasi-Deklaration verwendet werden kann. +% Dies wird beispielsweise für \KOMAScript-Optionen genutzt, um diese in der +% gewünschten Formatierung im Index erscheinen zu lassen. +% \begin{macrocode} + \else% +%</class> + \IfValueT{#5}{% +%<*class> + \ifstr{#5}{declare}{% + \appto\tud@lbl@tmp{-declare}% + \appto\tud@idx@fmt{|declare}% + }{% + \appto\tud@idx@fmt{|#5}% + }% +%</class> +%<*package> + \appto\tud@idx@fmt{|#5}% +%</package> + }% + \index[\tud@lbl@tmp]{\tud@idx@val\tud@idx@key{}@\tud@idx@fmt}% +%<*class> + \fi% +%</class> +} +% \end{macrocode} +% \end{macro}^^A \Process@@Index +% \end{macro}^^A \Process@Index +% +% \iffalse +%<*class> +% \fi +% +% \begin{macro}{\CrossIndex} +% Der Befehl \cs{CrossIndex} dient zum Eintragen eines Schlagwortes, welches im +% ersten obligatorischen Argument angegeben wird, in den allgemeinen Index und +% verweist auf den im zweiten obligatorischen Argument, zum Schlagwort gehörigen +% Spezialindex. Das ordinäre optionale Argument kann verwendet werden, um ggf. +% den Eintrag in den allgemeinen Index, der normalerweise mit dem jeweiligen +% Schlagwort erfolgt, zu überschrieben. +% +% Wird die Sternversion von \cs{CrossIndex} genutzt, so wird der Querverweis +% als Eintrag in der obersten Ebene gesetzt, andernfalls wird ein Untereintrag +% gesetzt. Mit der normalen Variante können so zu einem Schlagwort weitere +% Verweise im allgemeinen Index erscheinen. Das zweite obligatorische Argument +% kann eine kommagetrennte Liste enthalten. +% \begin{macrocode} +\NewDocumentCommand\CrossIndex{s m o m}{% + \def\@tempa##1##2##3{% + \index{% + \IfBooleanTF{#1}{##3@##3}{##3!"|@}% + \,\textrightarrow\,% + \tudhyperref{idx:##2}{\IfValueTF{##1}{##1}{Index der ##3}}|seeidx{##2}% + }% + }% + \forcsvlist{\@tempa{#3}{#4}}{#2}% +} +% \end{macrocode} +% \end{macro}^^A \CrossIndex +% \begin{macro}{\SeeRef} +% \changes{v2.05}{2015/11/05}{neu}^^A +% Mit \cs{SeeRef} wird unter dem im ersten Argument gegebenen Schlagwort ein +% Indexuntereintrag erzeugt, der wiederum auf einen Indexeintrag des zweiten +% Argumentes verweist. Dabei kann im zweiten Argument ein normaler Begriff oder +% ein Markup-Befehl verwendet werden. Normalerweise wird für den Querverweis +% die Referenzklasse \verb=|see= verwendet, die Sternversion des Befehls +% hingegen nutzt \verb=|seeunverified=, um auf eine Prüfung des verwiesenen +% Eintrags zu verzichten. +% \begin{macrocode} +\NewDocumentCommand\SeeRef{s m m}{% + \sbox\z@{% + \let\tud@idx@fmt\relax% + #3% +% \end{macrocode} +% Wurde im zweiten Argument ein Markup-Befehl angegeben, so wurde durch das +% Erstellen der Box das dazugehörige Indexformat in \cs{tud@idx@fmt} für den +% Eintrag erstellt. Andernfalls wurde die Definiton von \cs{tud@idx@fmt} nicht +% geändert und das Argument wird nach der Box direkt in den Index eingetragen. +% \begin{macrocode} + \ifx\tud@idx@fmt\relax% + \gdef\tud@reserved{#3}% + \else% + \global\let\tud@reserved\tud@idx@fmt% + \fi% + }% + \IfBooleanTF{#1}{\def\tud@idx@fmt{seeunverified}}{\def\tud@idx@fmt{see}}% + \index{#2!#3|\tud@idx@fmt{\tud@reserved}}% +} +% \end{macrocode} +% \end{macro}^^A \SeeRef +% +% \iffalse +%</class> +% \fi +% +% \subsubsection{Indexausgabe} +% +% Dies sind alle Befehle, die zur Ausgabe der erzeugten Indexe benötigt werden. +% \begin{macro}{\PrintIndex} +% \changes{v2.02}{2014/08/20}{neu}^^A +% \begin{macro}{\tud@indexprologue} +% \changes{v2.02}{2014/08/20}{neu}^^A +% Mit \cs{PrintIndex} erfolgt die Ausgabe aller erstellten Indexe. Dabei wird +% für bestimmte Spezialindexe das Makro \cs{tud@indexprologue} neu gesetzt, um +% für diese vor der eigentlichen Ausgabe einige Anmerkungen machen zu können. +% Mit \cs{tud@indexprologue} kann der einleitende Teil für einen Index gesetzt +% werden. +% \begin{macrocode} +%<*class> +\newcommand*\tud@indexprologue{} +%</class> +\newcommand*\PrintIndex{% + \begingroup% + \providecommand*\lettergroup[1]{% + \par\textbf{\textsf{##1}}\par% + \nopagebreak% + }% +%<*class> + \renewcommand\tud@indexprologue{% + Die im Folgenden aufgelisteten Schlagworte sollen f\"ur den Umgang mit + \hologo{LaTeXe} im Allgemeinen sowie dem \TUDScript-Bundle im Speziellen + sowohl Antworten bei generellen Fragen liefern als auch L\"osungen f\"ur + typische Probleme bereitstellen. Falls ein gesuchter Begriff hier nicht + auftaucht oder trotz vorhandener Hinweise kein zufriedenstellendes + Ergebnis erzielt werden kann, sollte das \Forum* erster Anlaufpunkt sein, + um weitere Hilfe bei der Nutzung von \TUDScript zu erhalten.% + }% +%</class> +%<*package> + \begingroup% + \let\lettergroup\@gobble% + \let\indexspace\relax% +%</package> + \print@index% +%<*package> + \endgroup% +%</package> +%<*class> + \clearpage% + \renewcommand\tud@indexprologue{% + Dies ist der Index aller im Handbuch erl\"auterten sowie erw\"ahnten + Optionen, wobei bei den meisten auch Untereintr\"age mit Seitenangaben + f\"ur spezielle Wertzuweisungen existieren.% + }% +%</class> + \print@index[options]% +%<*class> + \renewcommand\tud@indexprologue{% + Dies ist die Auflistung aller im Handbuch erl\"auterten sowie erw\"ahnten + Befehle und Umgebungen. Bei einigen existieren auch Untereintr\"age f\"ur + Schl\"ussel-Wert-Parameter, welche im optionalen Argument der jeweiligen + Anweisung verwendet werden k\"onnen. In der dritten Unterebene sind + gegebenenfalls Seitenverweise f\"ur explizite Wertzuweisungen an diese + Parameter zu finden.% + }% +%</class> + \print@index[macros]% +%<*class> + \renewcommand\tud@indexprologue{% + Dies sind alle von \TUDScript definierten, sprachabh\"angigen Bezeichner. + Informationen zur Verwendung sowie den Anpassungsm\"oglichkeiten sind in + \autoref{sec:localization} zu finden.% + }% + \print@index[terms]% + \print@index[elements]% +%</class> +%<*package> + \begingroup% + \let\lettergroup\@gobble% + \let\indexspace\relax% +%</package> + \print@index[misc]% +%<*package> + \endgroup% +%</package> + \print@index[files]% + \endgroup% +} +% \end{macrocode} +% \end{macro}^^A \tud@indexprologue +% \end{macro}^^A \PrintIndex +% \begin{macro}{\print@index} +% \changes{v2.02}{2014/07/25}{neu}^^A +% \begin{macro}{\tud@idx@skip} +% \changes{v2.02}{2014/09/02}{neu}^^A +% Mit \cs{@printindex} erfolgt die Ausgabe der einzelnen Indexe. Dabei wird in +% der Klasse \cls{tudscrmanual} zuvor für jeden Index ein referenzierbares +% Label erstellt und ggf. der Prolog gesetzt. +% +% Aufgrund der Verwendung der \env{multicols}-Umgebung durch das Paket +% \pkg{imakeidx} werden normalerweise ohne einen Prolog zu große vertikale +% Abstände gesetzt. Dies wird mit \cs{tud@idx@skip} behoben. +% \begin{macrocode} +\newcommand*\tud@idx@skip{% + \ifnum\imki@columns>\@ne\relax\vspace{-\multicolsep}\fi% +} +\newcommand*\print@index[1][]{% +% \end{macrocode} +% Falls ein Seitenumbruch notwendig ist, sollte dieser vor dem Index und nicht +% unmittelbar nach dem Beginn erfolgen. +% \begin{macrocode} + \pagebreak[3]% + \@tud@indextrue% +%<*class> +% \end{macrocode} +% Das zu erstellende Label wird in \cs{tud@reserved} gespeichert. Dabei wird +% die Sternversion von \cs{tudhyperdef} genutzt, um das Label auf die Höhe der +% Überschrift zu setzen. +% \begin{macrocode} + \ifblank{#1}{% + \def\tud@reserved{\tudhyperdef*{idx:main}}% + }{% + \def\tud@reserved{\tudhyperdef*{idx:#1}}% + }% +% \end{macrocode} +% Ohne Prolog wird der fehlerhafte vertikale Abstand behoben. +% \begin{macrocode} + \ifx\tud@indexprologue\@empty% + \indexprologue[\tud@idx@skip]{\tud@reserved}% +% \end{macrocode} +% Mit Prolog wird der fehlerhafte vertikale Abstand nach diesem korrigiert. +% \begin{macrocode} + \else% + \indexprologue{% + \tud@reserved% + \tud@indexprologue% + \tud@idx@skip% + }% + \fi% +%</class> +% \end{macrocode} +% Fur das Paket \pkg{tudscrtutorial} erfolgt eine einfache Ausgabe der Indexe. +% \begin{macrocode} +%<package> \indexprologue[\tud@idx@skip]{}% +% \end{macrocode} +% Die Ausgabe des gewünschten Index und des leeren des Prologs. +% \begin{macrocode} + \ifblank{#1}{\printindex}{\printindex[#1]}% + \ifnum\imki@columns>\@ne\relax\vspace{-\multicolsep}\fi% +%<class> \let\tud@indexprologue\@empty% +} +% \end{macrocode} +% \end{macro}^^A \tud@idx@skip +% \end{macro}^^A \print@index +% +% \iffalse +%<*class> +% \fi +% +% \subsection{Änderungsliste} +% +% Um dem Anwender einen schnellen Überblick zu Änderungen der aktuellen Version +% bereitstellen zu können, werden Befehle zur automatisierten Erzeugung einer +% solchen Liste definiert. Die Änderungsliste ist der Klasse \cls{tudscrmanual} +% vorbehalten. +% +% Änderungsnotizen lassen sich auf zwei unterschiedlichen Wegen generieren. +% Entweder über die Nutzung von \cs{ChangedAt} oder über das optionale Argument +% einer der Deklarationsumgebungen. Diese sind in der Form +% \meta{Versionsnummer}|:|\meta{Änderungsnotiz} anzugeben. Die alleinige Angabe +% der Versionsnummer ohne Änderungsnotiz ist ebenso möglich. +% +% Wird die Änderungsnotiz für ein bestimmtes Element wie eine Option oder ein +% Befehl erstellt, wie es bei den Deklarationsumgebungen implizit oder bei der +% Verwendung von \cs{ChangedAt} mit optionalem Argument geschieht, gibt es die +% zusätzliche Möglichkeit, einen Untereintrag zu erstellen. Dabei ist dieser +% nach Versionsnummer und vor Änderungsnotiz in folgender Form anzugeben: +% \meta{Versionsnummer}|!|\meta{Untereintrag}|:|\meta{Änderungsnotiz}. Der +% Untereintrag ist für die explizite Angabe eines Schlüssel-Wert-Paares gedacht. +% \begin{macro}{\if@tud@changedat} +% \begin{macro}{\Process@ChangedAt} +% \changes{v2.02}{2014/07/25}{erweitert}^^A +% \changes{v2.02}{2014/10/08}{Sternversion ergänzt}^^A +% Der Schalter \cs{if@tud@changedat} wird im weiteren Verlauf dazu verwendet, +% das Standardverhalten der einzelnen Markup-Befehle kurzeitig zu ändern und +% anstelle der Makros \cs{Process@Markup} und \cs{Process@Index} den Befehl +% \cs{Process@ChangedAt} auszuführen, mit welchem die Formatierung der Einträge +% der Änderungsliste erfolgt. +% \begin{macrocode} +\newif\if@tud@changedat +% \end{macrocode} +% Die Formatierung der Änderungseinträge erfolgt~-- wie auch für den Index~-- +% mit dem Makro \cs{tud@idx@get}, wobei die Sternversion für die Identifikation +% als Änderungseintrag fungiert. Aufgerufen wird \cs{Process@ChangedAt} während +% der Erstellung der Änderungseinträge mit \cs{Changed@At@CreateEntry}. Der +% Aufruf des Makros erfolgt dabei in gewohnter Form mit einem obligatorischen +% gefolgt von drei optionalen Argumenten: +% \newline\begingroup\scriptsize +% \cs{Process@ChangedAt}\marg{Element}|=|\meta{Wert}|=|\ignorespaces% +% \oarg{Ausgabesuffix}\parg{Bundleelement}\ignorespaces% +% \endgroup +% \begin{macrocode} +\NewDocumentCommand\Process@ChangedAt{md==od()}{% + \tud@idx@get*\tud@idx@key\tud@idx@fmt\tud@idx@val{#1}=#2=[#3](#4)% +} +% \end{macrocode} +% \end{macro}^^A \Process@ChangedAt +% \end{macro}^^A \if@tud@changedat +% \begin{macro}{\ChangedAt} +% \changes{v2.02}{2014/07/25}{erweitert}^^A +% \changes{v2.02}{2014/10/15}{Sternversion neu (keine Randnotiz)}^^A +% \changes{v2.06}{2018/09/03}{optionale Angabe des Bundles}^^A +% \begin{macro}{\@ChangedAt} +% \changes{v2.06}{2019/06/24}{neu}^^A +% \begin{length}{\changedatskip} +% \changes{v2.04}{2015/06/08}{neu}^^A +% Der Befehl \cs{ChangedAt} kann im Fließtext für das Erstellen einer freien +% Änderungsnotiz genutzt werden. Das obligatorische Argument sollt wie kurz +% zuvor beschrieben verwendet werden. +% +% Eine Änderungsnotiz wird für die angegebene Versionsnummer normalerweise im +% Abschnitt \enquote{Allgemein} aufgeführt. Soll jedoch eine Notiz explizit für +% eine Option, eine Umgebung, einen Befehlt etc. erstellt werden, kann dieses +% Element vor dem obligatorischen im optionalen Argument angegeben werden. Der +% Eintrag erfolgt dann im Abschnitt \enquote{Implementierung} für das gegebene +% Element. Im obligatorischen Argument können auch mehrere Änderungsnotizen +% gleichzeitig erzeugt werden. hierfür sind diese mit Semikolon voneinander zu +% trennen. Das Erzeugen der Liste erfolgt mit \cs{Changed@At@CreateList}. +% +% Normalerweise wird bei der Nutzung von \cs{ChangedAt} zusätzlich zum Eintrag +% in die Änderungsliste eine Randnotiz mit den angegebenen Versionsnummern +% erzeugt. Mit dem letzten optionalen Argument nach dem obligatorischen kann +% ein vertikaler Versatz dieser angegeben werden. Die Sternversion des Befehls +% unterdrückt die Ausgabe der Randnotiz. +% \begin{macrocode} +\newlength\changedatskip +\NewDocumentCommand\ChangedAt{s o d() m !O{\changedatskip}}{% + \IfValueTF{#2}{% + \Changed@At@CreateList[#2](#3){#4}% + }{% + \Changed@At@CreateList(#3){#4}% + }% +% \end{macrocode} +% Nach dem Erstellen der Liste wird diese abgearbeitet und ggf. die Randnotiz +% ausgegeben. +% \begin{macrocode} + \print@changedatlist{#1}{#5}% +} +% \end{macrocode} +% Die expandierbare Version des Befehls ist innerhalb von Überschriften nötig. +% \begin{macrocode} +\NewExpandableDocumentCommand\@ChangedAt{s o d() m}{} +\AfterPackage*{hyperref}{% + \pdfstringdefDisableCommands{% + \let\ChangedAt\@ChangedAt% + }% +} +\BeforeStartingTOC{\let\ChangedAt\@ChangedAt} +% \end{macrocode} +% \end{length}^^A \changedatskip +% \end{macro}^^A \@ChangedAt +% \end{macro}^^A \ChangedAt +% +% \subsubsection{Sukzessive Erstellung der Einträge für die Änderungsliste} +% +% Das Erstellen von Änderungsnotizen erfolgt in zwei Schritten. Diese werden +% zuerst mit dem Befehl \cs{Changed@At@CreateList} in einer standardisierten +% Form in der temporären Liste \cs{tud@changedat@list} gespeichert und später +% mit dem Makro \cs{Changed@At@CreateEntry} verarbeitet. Dieses Vorgehen liegt +% in den Umgebungen für Deklarationen begründet, welche verschachtelt werden +% können, jedoch einmalig mit \cs{printdeclarationlist} abgearbeitet werden. +% +% \begin{macro}{\tud@changedat@list} +% \changes{v2.02}{2014/07/25}{neu}^^A +% \begin{macro}{\forssvlist} +% \changes{v2.05}{2015/11/17}{neu}^^A +% Hier werden die Liste \cs{tud@changedat@list} sowie das Makro \cs{forssvlist} +% für die Aufspaltung der semikolongetrennten Änderungsnotizen definiert. +% \begin{macrocode} +\newcommand*\tud@changedat@list{} +\let\tud@changedat@list\relax +\DeclareListParser*{\forssvlist}{;} +% \end{macrocode} +% \end{macro}^^A \forssvlist +% \end{macro}^^A \tud@changedat@list +% \begin{macro}{\Changed@At@CreateList} +% \changes{v2.02}{2014/09/02}{neu}^^A +% \begin{macro}{\Changed@At@@CreateList} +% \changes{v2.02}{2014/10/09}{neu}^^A +% \begin{macro}{\Changed@At@@@CreateList} +% \begin{macro}{\Changed@At@@@@CreateList} +% Mit diesen Befehlen wird eine Liste im Format von \pkg{etoolbox} erzeugt, +% welche alle notwendigen Angaben für das Erzeugen der Änderungshistorie in +% Form eines Indexes mit \cs{Changed@At@CreateEntry} enthält. +% +% Der Befehl \cs{Changed@At@CreateList} kann vor dem obligatorischen Argument +% mit einem ordinären optionalen Argument verwendet werden, in welchem ein +% Makro, eine Umgebung, eine Option etc. angegeben wird. Ist dies der Fall, so +% wird der Eintrag in die Änderungsliste für dieses Element generiert, sonst +% wird eine allgemeiner Eintrag erzeugt. Das optionale Argument in runden +% Klammern wird lediglich verwendet, wenn für eine der beiden Spezialumgebungen +% \env{Declaration*} bzw. \env{Bundle*} eine Änderungsnotiz erstellt wird, um +% diese für das jeweilige \TUDScript-Bundle-Element in den entsprechenden +% Abschnitt der Änderungsliste einzutragen. Das Hauptargument verarbeitet +% schließlich eine semikolongetrennte Liste und reicht jeden Bestandteil +% zusammen mit den beiden optionalen Argumenten an \cs{Changed@At@@CreateList} +% weiter. +% \begin{macrocode} +\NewDocumentCommand\Changed@At@CreateList{od()m}{% + \IfValueT{#3}{\forssvlist{\Changed@At@@CreateList[#1](#2)}{#3}}% +} +% \end{macrocode} +% Mit \cs{Changed@At@@CreateList} wird lediglich die Versionsnummer von der +% eigentlichen Änderungsnotiz getrennt. +% \begin{macrocode} +\NewDocumentCommand\Changed@At@@CreateList{r[]r()>{\SplitArgument{1}{:}}m}{% + \Changed@At@@@CreateList[#1](#2)#3% +} +% \end{macrocode} +% Zuletzt wird durch \cs{Changed@At@@@CreateList} ein möglicher Untereintrag +% in ein separates Argument abgetrennt und \cs{Changed@At@@@@CreateList} mit +% allen Argumenten aufgerufen. +% \begin{macrocode} +\NewDocumentCommand\Changed@At@@@CreateList{r[]r()>{\SplitArgument{1}{!}}mm}{% + \Changed@At@@@@CreateList[#1](#2)#3{#4}% +} +% \end{macrocode} +% Der Befehl \cs{Changed@At@@@@CreateList} übernimmt nun die Erstellung des +% Eintrags in die Liste \cs{tud@changedat@list}. Wie bereits erwähnt, enthalten +% die beiden ersten Argumente ggf. Markup-Befehl und \TUDScript-Bundle-Element. +% Danach folgt die Versionsnummer der Änderungsnotiz, der mögliche Untereintrag +% für einen Markup-Befehl sowie die Änderungsnotiz selbst. +% +% Die oberste Gliederungsebene der Änderungshistorie ist die Versionsnummer. +% Unter dieser werden für jedes \TUDScript-Bundle-Element die Änderungsnotizen +% separat ausgegeben, wobei diese nochmal in einen allgemeinen Teil und einen +% zur Implementierung getrennt werden. +% +% Der im Folgenden erzeugte Eintrag für die Liste \cs{tud@changedat@list} wird +% in zwei unterschiedlichen Varianten generiert. In der Form +% \newline\begingroup\scriptsize +% \meta{Versionsnummer}|!Allgemein!|\meta{Änderungsnotiz}\ignorespaces% +% \endgroup\newline +% werden allgemeine Änderungsnotizen erstellt, für Einträge bezüglich der +% Implementierung wird die folgende Form genutzt: +% \newline\begingroup\scriptsize +% \meta{Versionsnummer}|!Implementierung!|\meta{Markup-Befehl}\ignorespaces% +% |!|\meta{Untereintrag}|!|\meta{Änderungsnotiz}\ignorespaces% +% \endgroup +% \begin{macrocode} +\NewDocumentCommand\Changed@At@@@@CreateList{r[]r()mmm}{% +% \end{macrocode} +% Die Aufteilung der Änderungsliste in die einzelnen \TUDScript-Bundle-Elemente +% erfolgt entweder anhand des explizit angegebenen optionalen Argumentes in +% runden Klammern oder aber implizit über den gegenwärtigen Inhalt des Makros +% \cs{tud@bdl@curr}. Dafür wird das Makro \cs{@tempa} so definiert, dass es +% das angegebene Argument in einer Box ausführt und das gesuchte Bundle-Element +% in \cs{@tempb} gespeichert ist. +% \begin{macrocode} + \def\@tempa##1{% + \sbox\z@{% + \let\tud@idx@fmt\relax% + \@tud@changedattrue% + ##1% + \@tud@changedatfalse% + \ifx\tud@idx@fmt\relax% + \gdef\@tempb{##1}% + \else% + \global\let\@tempb\tud@idx@fmt% + \fi% + }% + }% + \let\@tempb\@empty% + \IfValueTF{#2}{% + \@tempa{#2}% + }{% + \tud@if@bdl{\@tempa{\tud@bdl@curr}}{}% + }% +% \end{macrocode} +% Nachdem klar ist, für welches Bundle-Element ggf. der Änderungslisteneintrag +% erzeugt werden soll, wird nun bestimmt, ob dieser im allgemeinen Teil oder in +% den zur Implementierung erscheinen soll. Dies wird an der Existenz des ersten +% Argumentes entschieden. Ist es vorhanden, handelt es sich um einen Eintrag +% für den Implementierungsteil, welcher in \cs{tud@changedat@list} in der Form +% \newline\begingroup\scriptsize +% \meta{Versionsnummer}|!Implementierung!|\meta{Markup-Befehl}\ignorespaces% +% |!|\meta{Untereintrag}|!|\meta{Änderungsnotiz}\ignorespaces% +% \endgroup\newline +% gespeichert wird, wobei der Untereintrag auch leer bleiben kann. +% \begin{macrocode} + \IfValueTF{#1}{% + \toks@{#3!Implementierung }% +% \end{macrocode} +% Hier erfolgt ggf. der Eintrag des \TUDScript-Bundle-Elements, danach folgt +% der Markup-Befehl. +% \begin{macrocode} + \eaddto@hook\toks@{\@tempb}% + \addto@hook\toks@{!#1!}% +% \end{macrocode} +% Wurde ein Untereintrag angegeben, wird dieser hier gefolgt von der +% eigentlichen Änderungsnotiz eingefügt. Für obsolete Deklarationen für die +% Änderungsnotiz in jedem Fall ignoriert, da beim späteren Aufruf des Makros +% \cs{Changed@At@CreateEntry} eine Standardmeldung ausgegeben wird. +% \begin{macrocode} + \IfValueT{#4}{\addto@hook\toks@{#4}}% + \addto@hook\toks@{!}% + \if@tud@obsolete\else% + \IfValueT{#5}{\addto@hook\toks@{#5}}% + \fi% + }{% +% \end{macrocode} +% Handelt es sich um einen allgemeinen Änderungseintrag, wird dieser in der Form +% \newline\begingroup\scriptsize +% \meta{Versionsnummer}|!Allgemein!|\meta{Änderungsnotiz}\ignorespaces% +% \endgroup\newline +% in der Liste \cs{tud@changedat@list} gespeichert. Für den allgemeinen Teil +% wird mit der Angabe eines \TUDScript-Bundle-Elements etwas anders verfahren. +% Wurde dieses~-- wenn auch nur indirekt über eine der beiden Spezialumgebungen +% \env{Declaration*} bzw. \env{Bundle*}~-- angegeben, so wird der Eintrag in +% den allgemeinen Hauptteil als Untereintrag erzeugt. Erfolgte die Verwendung +% jedoch innerhalb einer \TUDScript-Bundle-Deklaration, so erscheint der +% Eintrag im allgemeinen Teil für das explizite Bundle-Element. +% \begin{macrocode} + \toks@{#3!Allgemein }% + \IfValueTF{#2}{% + \addto@hook\toks@{!}% + \eaddto@hook\toks@{\@tempb:\space}% + \IfValueTF{#5}{% + \addto@hook\toks@{#5}% + }{% + \addto@hook\toks@{\emph{neu}}% + }% + }{% + \eaddto@hook\toks@{\@tempb}% + \addto@hook\toks@{!}% + \addto@hook\toks@{#5}% + }% + \IfValueT{#4}{% + \ClassError{tudscrmanual}{Using !#4 isn't allowed for a change notice}{% + At least, it has to be implemented!% + }% + }% + }% + \listeadd\tud@changedat@list{\the\toks@}% +} +% \end{macrocode} +% \end{macro}^^A \Changed@At@@@@CreateList +% \end{macro}^^A \Changed@At@@@CreateList +% \end{macro}^^A \Changed@At@@CreateList +% \end{macro}^^A \Changed@At@CreateList +% +% \subsubsection{Erzeugen der Änderungseinträge} +% +% Mit den nachfolgenden Makros erfolgt das eigentliche Eintragen der +% Änderungseinträge aus der Liste \cs{tud@changedat@list} in den entsprechenden +% Index~\val{changelog}. +% +% \begin{macro}{\Changed@At@CreateEntry} +% \changes{v2.02}{2014/09/02}{neu}^^A +% \begin{macro}{\Changed@At@@CreateEntry} +% \changes{v2.02}{2014/09/02}{neu}^^A +% Der Befehl \cs{Changed@At@CreateEntry} wird durch \cs{@printchangedatlist} +% aufgerufen und teilt die gegebene Liste am Delimiter Ausrufezeichen |!| in +% fünf Argumente auf und reicht sie an \cs{Changed@At@@CreateEntry} weiter. +% Sind weniger als vier Ausrufezeichen vorhanden, so werden die ungenutzten +% Argumente mit dem~-- durch das Paket \pkg{xparse} definierten~-- leeren Wert +% \val{-NoValue-} an den Befehl \cs{Changed@At@@CreateEntry} übergeben. +% \begin{macrocode} +\NewDocumentCommand\Changed@At@CreateEntry{>{\SplitArgument{4}{!}}m}{% + \Changed@At@@CreateEntry#1% +} +% \end{macrocode} +% Mit \cs{Changed@At@@CreateEntry} wird der Eintrag in die Änderungshistorie +% erzeugt, falls denn überhaupt ein Eintrag generiert werden soll. Dies wird +% daran erkannt, ob das dritte Argument dew Wert \val{-NoValue-} entspricht +% oder eben nicht. Der zweite Fall tritt auf, wenn lediglich eine Randnotiz +% gesetzt werden soll. Die in \cs{tud@changedat@list} gespeicherten Einträge +% haben die Form +% \newline\begingroup\scriptsize +% \meta{Versionsnummer}|!Allgemein!|\meta{Änderungsnotiz}\ignorespaces% +% \endgroup\newline +% oder +% \newline\begingroup\scriptsize +% \meta{Versionsnummer}|!Implementierung!|\meta{Markup-Befehl}\ignorespaces% +% |!|\meta{Untereintrag}|!|\meta{Änderungsnotiz}\ignorespaces% +% \endgroup +% \begin{macrocode} +\newcommand*\Changed@At@@CreateEntry[5]{% + \IfValueT{#3}{% +% \end{macrocode} +% Bei der Deklaration von Optionen, Befehlen etc. werden diese automatisch in +% der Liste der Änderungen im Bereich \enquote{Implementierung} vor der +% gegebenen Erklärung selbst ausgegeben. Hierfür wird die Existenz des vierten +% Arguments geprüft. Ist dieses vorhanden\dots +% \begin{macrocode} + \IfValueTF{#4}{% +% \end{macrocode} +% \dots befindet sich im dritten Argument der Markup-Befehl für den Eintrag im +% Implementierungsteil. Mit dem zwischenzeitlichen Aktivieren des Schalters +% \cs{if@tud@changedat} wird beim nachfolgenden Aufruf des Markup-Befehls das +% Makro \cs{Process@ChangedAt} ausgeführt und dadurch auch \cs{tud@idx@get*} +% aufgerufen, wodurch in den Makros \cs{tud@idx@key}, \cs{tud@idx@fmt} und +% \cs{tud@idx@val} die passend formatierten Indexeinträge enthalten sind. +% \begin{macrocode} + \@tud@changedattrue% + #3% + \@tud@changedatfalse% +% \end{macrocode} +% Das vierte Argument erstellt in der Änderungsliste einen Untereintrag für den +% im dritten Argument gegebenen Markup-Befehl. Dies wird für Anmerkungen zu +% expliziten Schlüssel-Wert-Paaren bei Optionen oder Parametern genutzt. +% \begin{macrocode} + \ifxblank{#4}{}{% +% \end{macrocode} +% Hierfür wird die zuvor erhaltene Formatierung des Markup-Befehls des dritten +% Argumentes an den Haupteintrag \cs{tud@idx@val} mit der zusätzlichen +% Anmerkung \enquote{Werte angepasst} angehängt. +% \begin{macrocode} + \eappto\tud@idx@val{% + \expandonce\tud@idx@key: Werte angepasst@% + \expandonce\tud@idx@fmt: Werte angepasst!% + }% +% \end{macrocode} +% Anschließend werden die Formatierungsbefehle des vierten Arguments genutzt, +% wobei vom Befehl \cs{suffix} nur das Argument selbst benötigt wird. Um den +% Inhalt von \cs{tud@idx@val} zu schützen, erfolgt das ganze in einer Gruppe. +% \begin{macrocode} + \begingroup% + \@tud@changedattrue% + #4% + \@tud@changedatfalse% + \let\suffix\@gobble% + \protected@edef\tud@reserved{% + \noexpand\endgroup% + \def\noexpand\tud@idx@key{\tud@idx@key}% + \def\noexpand\tud@idx@fmt{\tud@idx@fmt}% + }% + \tud@reserved% + }% +% \end{macrocode} +% Nachdem die Formatierung der Haupt- und Untereinträge soweit zusammengebaut +% wurden, wird die eigentliche Änderungsnotiz des fünften Arguments angehangen. +% Dabei wird für den Fall, dass \emph{keine} Erklärung angegeben wurde, in der +% Änderungsliste vermerkt, ob es sich bei dem Markup-Befehl respektive dessen +% Untereintrag um eine \emph{neue} bzw. eine \emph{obsolete} Variante handelt. +% \begin{macrocode} + \ifxblank{#5}{% + \if@tud@obsolete% + \appto\tud@idx@fmt{: \emph{entf\"allt}}% + \else% + \appto\tud@idx@fmt{: \emph{neu}}% + \fi% +% \end{macrocode} +% Existiert ein Eintrag, wird dieser für Schlüssel und Format verwendet. +% \begin{macrocode} + }{% + \appto\tud@idx@key{: #5}% + \appto\tud@idx@fmt{: #5}% + }% +% \end{macrocode} +% Nachdem alles abgearbeitet wurde, wird der Indexeintrag erstellt. +% \begin{macrocode} + \index[changelog]{#1!#2!\tud@idx@val\tud@idx@key @\tud@idx@fmt}% +% \end{macrocode} +% Existiert das vierte Argument nicht, handelt es sich um einen allgemeinen +% Eintrag in der Änderungshistorie. Dieser wird direkt ausgeführt. +% \begin{macrocode} + }{% + \index[changelog]{#1!#2!#3}% + }% + }% +% \end{macrocode} +% Außerdem wird der Liste \cs{tud@templist} die aktuelle Version einmalig +% hinzugefügt, um alle Versionsangaben in einer Randnotiz ausgeben zu können. +% \begin{macrocode} + \ifinlist{#1}{\tud@templist}{}{\listadd\tud@templist{#1}}% +} +% \end{macrocode} +% \end{macro}^^A \Changed@At@@CreateEntry +% \end{macro}^^A \Changed@At@CreateEntry +% +% \subsubsection{Ausgabe der Änderungsliste} +% +% Ähnlich wie für den Index wird auch für die Änderungsliste bei der Ausgabe +% verfahren. +% +% \begin{macro}{\PrintChangelog} +% \begin{environment}{theindex} +% Mit \cs{PrintChangelog} erfolgt die Ausgabe der Änderungsliste. Dabei ist zu +% beachten, dass die Einträge im Index bis zur vierten Ebene erfolgen. +% \begin{macrocode} +\newcommand*\PrintChangelog{% + \begingroup% +% \end{macrocode} +% Die oberste Ebene enthält die Versionsnummer mit dem Präfix |v|. Diese Ebene +% soll nicht als Indexeintrag selber sondern vielmehr als Überschrift der Ebene +% \cs{subsection} genutzt werden. Dafür wird zum einen das durch das Paket +% \pkg{imakeidx} definierte Makro \cs{lettergroup} \emph{unschädlich} gemacht, +% zum anderen wird der Befehl \cs{item} so umdefiniert, dass dieser alles bis +% zum nächsten Zeilenumbruch als Argument einliest. Alle darunter liegenden +% \cs{item}-Befehle werden eine Ebene nach oben gehoben. +% \begin{macrocode} + \let\lettergroup\@gobble% + \apptocmd{\theindex}{% + \let\subsubsubitem\subsubitem% + \let\subsubitem\subitem% + \let\subitem\item% + \renewcommand*\item{% + \begingroup% + \escapechar=`\\% + \catcode\endlinechar=\active% + \csname\string\item\endcsname% + }% + \begingroup% + \escapechar=`\\% + \lccode`\~=\endlinechar% + \lowercase{% + \expandafter\endgroup% + \expandafter\def\csname\string\item\endcsname##1~% + }{% + \endgroup% + \let\@tempb\@firstofone% + \if@tud@cdoldfont@active\def\@tempb##1{\NoCaseChange{##1}}\fi% + \addsec[##1]{\TUDScript \@tempb{##1}}% + \tudhyperdef*{idx:changelog:##1}% + \def\@tempa{\indexname: \TUDScript \@tempb{##1}}% + \@mkboth{\@tempa}{\@tempa}% + }% + }{}{\tud@patch@wrn{theindex}}% +% \end{macrocode} +% Mit der so angepassten \env{theindex}-Umgebung erfolgt die Ausgabe der +% Änderungshistorie. +% \begin{macrocode} + \clearpage% + \def\imki@indexlevel{\addchap}% + \print@index[changelog]% + \endgroup% +} +% \end{macrocode} +% \end{environment}^^A theindex +% \end{macro}^^A \PrintChangelog +% \begin{macro}{\print@changedatlist} +% \changes{v2.02}{2014/10/09}{neu}^^A +% Die Einträge in der Liste der Änderungen \cs{tud@changedat@list} werden mit +% dem Makro \cs{Changed@At@CreateList} abgearbeitet, sortiert und erstellt. Das +% zweite obligatorische Argument von \cs{@printchangedatlist} steurrt den +% vertikalen Versatz der Randnotiz. Wird im ersten Argument das boolesche Flag +% zu \cs{BooleanTrue} gesetzt, wird die Randnotiz unterdrückt. +% \begin{macrocode} +\NewDocumentCommand\print@changedatlist{mm}{% + \ifx\tud@changedat@list\relax\else% + \let\tud@templist\relax% + \forlistloop\Changed@At@CreateEntry{\tud@changedat@list}% + \global\let\tud@changedat@list\relax% +% \end{macrocode} +% Nach der Verarbeitung der Einräge sind in \cs{tud@templist} alle angegebenen +% Versionsnummern genau einmal enthalten. Mit \cs{tud@list@sort} werden diese +% in die richtige Reihenfolge sortiert und anschließend als Randnotiz in einer +% Tabelle ausgegeben, falls nicht die Sternversion verwendet wurde. +% \begin{macrocode} + \IfBooleanF{#1}{% + \tud@list@sort\tud@templist% + \strut% + \marginnote{% + \def\@tempa####1{% + \ignorespaces% + \tudhyperref{idx:changelog:####1}{####1}% + \tabularnewline% + }% + \begin{tabular}{|l|}% + \hline% + \forlistloop\@tempa{\tud@templist}% + \hline% + \end{tabular}% + }[#2]% + \ignorespaces% + }% + \fi% +} +% \end{macrocode} +% \end{macro}^^A \print@changedatlist +% +% \subsection{Erweiterte Listen für Erläuterungen im Handbuch} +% +% Es folgen einige Umgebungen, mit welchen bestimmte Aspekte oder Pakete im +% Handbuch erläutert werden. +% +% Das Paket \pkg{enumitem} erlaubt das Beeinflussen der Standardlisten und die +% Ableitung neuer Listen aus diesen. Mit \cs{setlist\{noitemsep\}} werden die +% zusätzlichen Zwischenräume innerhalb der Listen beseitigt. Weiterhin wird +% linksbündiger Flattersatz für die Standardlisten aktiviert. +% \begin{macrocode} +\RequirePackage{enumitem}[2011/09/28] +\setlist{before*={\endgraf\tud@RaggedRight},partopsep=0pt,noitemsep} +% \end{macrocode} +% \begin{macro}{\stditem} +% \begin{macro}{\tud@before@item} +% Mit den Möglichkeiten des Paketes \pkg{enumitem} werden folgend Listen für +% das Aufführen von möglichen Werten einer Option sowie der Beschreibung von +% nützlichen Paketen erstellt. Für beide Listen soll dabei die originale +% Definition von \cs{item} in \cs{stditem} gesichert und anschließend angepasst +% werden. Die Sicherung und Redefinition von \cs{item} erfolgt dabei über das +% Makro \cs{tud@before@item} über einen bereitgestellten \emph{hook} zu Beginn +% der jeweiligen Liste. +% \begin{macrocode} +\newcommand*\stditem{} +\newcommand*\tud@before@item[1]{% + \ifdefvoid{\stditem}{% + \let\stditem\item% + \letcs\item{tud@item@#1}% +% \end{macrocode} +% Damit die Änderungsnotizen in der passenden vertikalen Position erscheinen, +% wird die Länge \cs{changedatskip} entsprechend angepasst. +% \begin{macrocode} + \setlength\changedatskip{-\baselineskip}% + }{}% +} +% \end{macrocode} +% \end{macro}^^A \tud@before@item +% \end{macro}^^A \stditem +% +% \subsubsection{Listen für gültige Werte von Optionen} +% +% \begin{environment}{values} +% \begin{environment}{@values} +% \begin{macro}{\tud@values} +% Die Liste \env{@values} dient zum Benennen der möglichen Werte für einen +% bestimmten Schlüssel. Im Handbuch kommt diese Liste vor allem bei Optionen +% aber ggf. auch bei bestimmten Befehls- und Optionsparametern zum Einsatz. +% Diese wird in der Umgebung \env{values} eingebettet, damit zum einen ein +% \emph{obligatorisches} Argument verwendet werden kann und zum anderen +% \emph{nach} diesem ein optionales für die Liste selbst verwendbar ist. Das +% obligatorische Argument wird in \cs{tud@values} gesichert und sollte die +% genauer zu beschreibende Option bzw. das Makro etc. enthalten. +% \begin{macrocode} +\newcommand*\tud@values{} +\NewDocumentEnvironment{values}{mo}{% + \def\tud@values{#1}% + \IfValueTF{#2}{\@values[#2]}{\@values}% +}{% + \end@values% +} +\newlist{@values}{description}{1} +\setlist[@values]{% + topsep=\smallskipamount,labelwidth=\linewidth,labelsep=0pt,% + font=\normalfont,parsep=\parskip,listparindent=\parindent,% + before=\tud@before@item{values}% +} +% \end{macrocode} +% \end{macro}^^A \tud@values +% \end{environment}^^A @values +% \end{environment}^^A values +% \begin{macro}{\tud@item@values} +% \begin{macro}{\forslashlist} +% Das Makro \cs{tud@item@values} ersetzt in der Umgebung \env{values} die +% originale Definiton von \cs{item}. Die Sternversion kann dabei verwendet +% werden, um die Einstellung für den Säumniswert hervorzuheben. Im ersten +% optionalen Argument können die möglichen Werte einer Option oder eines +% Parameters angegeben werden. Sind mehrere Werte gleichbedeutende Werte +% verwendbar, so sind diese durch |/| zu trennen. Dabei wird der als erstes +% angegebene Wert für den Untereintrag in den Index verwendet. Das zweite +% optionale Argument kann genutzt werden, falls beispielsweise für +% unterschiedliche Klassen sich der Säumniswert unterscheidet. Das letzte +% optionale Argument in runden Klammern fügt zum Schluss einen ergänzenden +% Eintrag hinzu. +% \begin{macrocode} +\DeclareListParser*{\forslashlist}{/} +\NewDocumentCommand\tud@item@values{sood()}{% +% \end{macrocode} +% Alle Auszeichnungen kommen nur zum Tragen, wenn ein optionales Argument für +% die Werte angegeben wurde. +% \begin{macrocode} + \IfValueTF{#2}{% +% \end{macrocode} +% Die durch Schrägstrich getrennte Liste im optionalen Argument wird mit +% \cs{forslashlist} durchlaufen. Der erste Eintrag wird für den Indexeintrag +% benötigt und in \cs{@tempc} gesichert, alle weiteren Einträge werden in +% \cs{@tempb} gespeichert und lediglich im Fließtext aufgelistet. +% \begin{macrocode} + \let\@tempc\@empty% + \def\tud@reserved##1{% + \if@tempswa% + \appto\@tempb{/##1}% + \else% + \@tempswatrue% + \let\@tempb\@empty% + \def\@tempc{##1}% + \fi% + }% + \@tempswafalse% + \forslashlist\tud@reserved{#2}% +% \end{macrocode} +% Jetzt beginnt die Formatierung der Ausgabe. Zuerst wird die zu beschreibende +% Option in \cs{@tempa} expandiert. Danach wird der erste Wert angehangen, +% wobei dieser für die Sternversion als Säumniswert mit \cs{emph} hervorgehoben +% wird. Zuletzt wird dafür Sorge getragen, dass auf den anschließend erzeugten +% Eintrag selbst kein Hyperlink erzeugt wird und dieser im passenden Index als +% fettmarkierter Eintrag erscheint. +% \begin{macrocode} + \edef\@tempa{\expandonce\tud@values}% + \protected@eappto\@tempa{% + =\IfBooleanTF{#1}{\noexpand\emph}{\@firstofone}{\@tempc}=% + }% + \appto\@tempa{'none'|!|}% +% \end{macrocode} +% Danach werden alle weiteren möglichen Werte angegeben, wobei auch diese im +% Zweifelsfall mit \cs{emph} hervorzuheben sind. +% \begin{macrocode} + \edef\@tempb{% + \IfBooleanTF{#1}{\noexpand\emph}{\@firstofone}{% + \noexpand\PValue{\@tempb}% + }% + }% +% \end{macrocode} +% Zuletzt erfolgt die Auszeichnung, ob es sich bei den gelisteten Werten um +% Säumniswerte handelt, gefolgt vom optionael Suffix. +% \begin{macrocode} + \IfBooleanTF{#1}{% + \appto\@tempb{\suffix{S\"aumniswert}}% + }{% + \IfValueT{#3}{\appto\@tempb{\suffix{S\"aumniswert f\"ur #3}}}% + }% + \IfValueT{#4}{\appto\@tempb{\suffix{#4}}}% +% \end{macrocode} +% Die in \cs{tud@values} gespeicherte, zu beschreibende Option bzw. Makro etc. +% und der erste im optionalen Argument angegebene Wert werden verwendet, um ein +% Label zu erstellen. +% \begin{macrocode} + \tud@lbl@get@curr*\tud@lbl@tmp{\tud@bdl@curr:\tud@values}=\@tempc=% +% \end{macrocode} +% Abschließend erfolgt wird die Ausgabe des generierten Eintrags mit dem +% originalen Makro \cs{stditem}. +% \begin{macrocode} + \stditem[\tudhyperdef{\tud@lbl@tmp}\@tempa\@tempb]% + }{% + \stditem% + }% +} +% \end{macrocode} +% \end{macro}^^A \forslashlist +% \end{macro}^^A \tud@item@values +% \begin{macro}{\itemtrue} +% \begin{macro}{\itemfalse} +% \begin{macro}{\tud@item@bool} +% Die folgenden beiden Befehle sind äquivalent zu \cs{tud@item@values} genutzt +% werden. Diese enthalten allerdings im optionalen Argument zumindest die +% Standardwerte für positive bzw. negative boolesche Schalter. Diese werden +% durch den Befehl \cs{item@bool} gesetzt. +% \begin{macrocode} +\NewDocumentCommand\itemtrue{!s !o !o !d()}{% + \item@bool{#1}{true/on/yes}[#2][#3](#4)% +} +\NewDocumentCommand\itemfalse{!s !o !o !d()}{% + \item@bool{#1}{false/off/no}[#2][#3](#4)% +} +% \end{macrocode} +% Der Befehl \cs{item@bool} setzt je nach angegebenen Argumenten über ein +% token-Register den auszuführenden \cs{item}-Befehl zusammen. +% \begin{macrocode} +\NewDocumentCommand\item@bool{mmr[]r[]r()}{% + \toks@{\item}% + \IfBooleanT{#1}{\addto@hook\toks@{*}}% +% \end{macrocode} +% Die optionalen Werte werden im Zweifel den booleschen Standardwerten +% angehängt und als einziges optionales Argument an \cs{item} übergeben. +% \begin{macrocode} + \protected@edef\@tempa{#2\IfValueT{#3}{/#3}}% + \eaddto@hook\toks@{\expandafter[\@tempa]}% + \IfValueT{#4}{\addto@hook\toks@{[#4]}}% + \IfValueT{#5}{\addto@hook\toks@{(#5)}}% + \the\toks@% +} +% \end{macrocode} +% \end{macro}^^A \itemfalse +% \end{macro}^^A \itemtrue +% \end{macro}^^A \tud@item@bool +% +% \subsubsection{Listen für die Beschreibung von Paketen} +% +% \begin{environment}{packages} +% \begin{macro}{\tud@item@packages} +% \changes{v2.02}{2014/10/09}{optionales Argument für CTAN-Link}^^A +% \changes{v2.04}{2015/03/12}{optionales Argument für weitere Pakete}^^A +% Ähnlich wie für die Auflistung von Werten eines Schlüssels wird auch mit der +% Charakterisierung von Paketen verfahren. Diese werden in der Auflistung +% speziell gekennzeichnet. +% \begin{macrocode} +\newlist{packages}{description}{2} +\setlist[packages]{% + topsep=\smallskipamount,labelwidth=\linewidth,labelsep=0pt,% + font=\normalfont,parsep=\parskip,listparindent=\parindent,% + before=\tud@before@item{packages}% +} +% \end{macrocode} +% Hiermit können ein oder mehrere Pakete erläutert werden. Des Weiteren werden +% Textanker definiert, auf die im Zweifelsfall in der Dokumentation verlinkt +% wird. +% \begin{macrocode} +\NewDocumentCommand\tud@item@packages{od<>d()}{% +% \end{macrocode} +% Die kommagetrennte Liste im optionalen Argument wird verwendet, um jedes +% einzelnen Paket aufzulisten und einen dazugehörigen Textanker zu erzeugen. +% Das optionale Argument in Guillemets kann genutzt werden, um \emph{alle} +% gelisteten Pakete auf den gleichen CTAN-Link zielen zu lassen. Dies ist +% beispielsweise für mehrere Pakete aus dem gleichen Bundle sinnvoll. +% \begin{macrocode} + \def\@tempa##1{% + \@tempc% + \tud@lbl@get@curr*\tud@lbl@tmp{\tud@bdl@curr:\Package{##1}}% + \tudhyperdef{\tud@lbl@tmp}% + \begingroup% + \Package{##1}<#2>'url'|!|% + \endgroup% + \def\@tempc{, }% + }% + \stditem[{% + \IfValueT{#1}{% + \let\@tempc\relax% + \forcsvlist\@tempa{#1}% +% \end{macrocode} +% Wird im dritten optionalen Argument in runden Klammern ein Paket angegeben, +% so wird ebenfalls ein Textanker erzeugt, allerdings auf einen Hyperlink zu +% CTAN verzichtet. +% \begin{macrocode} + \IfValueT{#3}{% + \tud@lbl@get@curr*\tud@lbl@tmp{\tud@bdl@curr:\Package{#3}}% + \quad(\tudhyperdef{\tud@lbl@tmp}\Package{#3}'none'|!|)% + }% + }% + }]% +} +% \end{macrocode} +% \end{macro}^^A \tud@item@packages +% \end{environment}^^A packages +% +% \subsection{Erläuterungen und weiterführende Ergänzungen im Handbuch} +% \subsubsection{Tabelle mit automatisch berechneter Mehrspaltenzellenbreite} +% +% \begin{environment}{tabularm} +% \begin{macro}{\tabularm@allcolumnpar} +% \begin{macro}{\tabularm@box} +% \begin{macro}{\tabularm@num} +% \begin{length}{\tabularm@wd} +% \begin{length}{\tempdim} +% \changes{v2.02}{2014/08/16}{neu}^^A +% Die Umgebung \env{tabularm} ist eine Erweiterung der \env{tabular}-Umgebung. +% In dieser wird die Breite der zu setzenden Tabelle mit Hilfe der Box +% \cs{tabularm@box} in \cs{tabularm@wd} gespeichert. Anschließend kann mit dem +% Befehl \cs{allcolumnpar} eine Zeile über alle Spalten der Tabelle ausgegeben +% werden. Dabei ist das zu übergebende Argument die Anzahl der zu erzeugenden, +% linksbündigen Spalten. +% \begin{macrocode} +\newlength\tempdim +\newsavebox\tabularm@box +\newlength\tabularm@wd +\newcommand*\tabularm@num{1} +\NewEnviron{tabularm}[1]{% + \begin{lrbox}{\tabularm@box}% + \let\allcolumnpar\@gobble% + \begin{tabular}{*{#1}l}\BODY\end{tabular}% + \end{lrbox}% + \setlength\tabularm@wd{\wd\tabularm@box}% + \def\tabularm@num{#1}% + \let\allcolumnpar\tabularm@allcolumnpar% + \begin{tabular}{*{#1}l}\BODY\end{tabular}% +} +\newcommand*\tabularm@allcolumnpar[1]{% + \multicolumn{\tabularm@num}{@{}p{\tabularm@wd}@{}}{#1}% +} +% \end{macrocode} +% \end{length}^^A \tempdim +% \end{length}^^A \tabularm@wd +% \end{macro}^^A \tabularm@box +% \end{macro}^^A \tabularm@num +% \end{macro}^^A \tabularm@allcolumnpar +% \end{environment}^^A tabularm +% +% \subsubsection{Tabelle für mehrsprachigen Bezeichner} +% +% Mit Hilfe von \pkg{tabularx} können Tabellen bestimmter Breite und +% automatisch berechneten Spaltenbreiten gesetzt werden. +% \begin{macrocode} +\RequirePackage{tabularx}[1999/01/07] +% \end{macrocode} +% \begin{macro}{\TermTable} +% \begin{macro}{\Term@Table} +% \begin{macro}{\Term@@Table} +% Für sprachabhängige Bezeichner wird zusätzlich der Befehl \cs{TermTable} +% definiert, dem eine kommaseparierte Liste übergeben werden kann. Anhand +% dieser Liste werden die enthalten Begriffe für die Sprachen Deutsch und +% English in einer Tabelle ausgegeben. Die Sternversion dieses Befehls nutzt +% dafür die \env{tabularx}-Umgebung. Für diese kann ein zweites Argument +% angegeben werden, welches die gewünschte Breite der Tabelle angibt. +% \begin{macrocode} +\NewDocumentCommand\TermTable{s m !g}{% + \let\tud@templist\relax% + \forcsvlist{\listadd\tud@templist}{#2}% + \ifhmode\par\fi% + \vskip\medskipamount% + \@afterindentfalse\@afterheading% + \IfBooleanTF{#1}{% + \IfValueTF{#3}{\setlength\@tempdima{#3}}{\setlength\@tempdima{\linewidth}}% + \setlength\@tempdimc{-.7\baselineskip}% + \begin{tabularx}{\@tempdima}{lXX}\Term@Table\end{tabularx}% + }{% + \setlength\@tempdimc{\z@}% + \begin{tabular}{lll}\Term@Table\end{tabular}% + }% + \par\addvspace{\medskipamount}% +} +\newcommand*\Term@Table{% + \toprule% + \textbf{Bezeichner} & \textbf{Deutsch} & \textbf{Englisch}\tabularnewline% + \midrule% + \forlistloop\Term@@Table{\tud@templist}% + \bottomrule% +} +\newcommand*\Term@@Table[1]{% + \Term{#1}'none' & % + \ifstr{\csuse{#1}}{}{\PName{leer}}{\csuse{#1}} & % + \selectlanguage{english}\vspace*{\@tempdimc}% + \ifstr{\csuse{#1}}{}{\PName{empty}}{\csuse{#1}}\tabularnewline% +} +% \end{macrocode} +% \end{macro}^^A \Term@@Table +% \end{macro}^^A \Term@Table +% \end{macro}^^A \TermTable +% +% \subsubsection{Umgebung für die Angabe eines Beispiels} +% +% \begin{environment}{Example} +% \begin{environment}{Example*} +% Diese Umgebung wird für die exemplarische Erläuterung von bestimmten Aspekten +% im Handbuch verwendet. Wenn dafür ein Quelltextauszug nötig ist, kann +% innerhalb dieser die \env{Code}-Umgebung genutzt werden. Die Sternversion +% unterdrückt dabei das Zurücksetzen des eigentlich entfernten vertikalen +% Abstandes. +% \begin{macrocode} +\newenvironment{Example}{\csuse{Example*}}{% + \csuse{endExample*}% + \addvspace{-\topsep}% +} +\newenvironment{Example*}{% + \labeling{{\usekomafont{disposition}{Beispiel:\nobreakspace}}}% + \item[{\usekomafont{disposition}{Beispiel:\nobreakspace}}]% +}{% + \endlabeling% +} +% \end{macrocode} +% \end{environment}^^A Example* +% \end{environment}^^A Example +% +% \iffalse +%</class> +% \fi +% +% \subsection{Lesen und Schreiben von Hilfsdateien} +% +% Für den Anwender werden im \TUDScript-Bundle einige Tutorials mit Hinweisen +% zur Nutzung von \LaTeXe{} bereitgestellt. Innerhalb dieser werden Auszüge von +% Quelltexten verwendet und erläutert. Zum einen soll die Möglichkeit +% geschaffen werden, diese gesammelt am Ende eines Tutorials für ein +% Copy"~\&"~Paste"~Beispiel zu verwenden. Andererseits soll auch das sofortige +% Ausführen des beschriebenen Quelltextauszuges direkt im Tutorial möglich +% sein. +% +% Dafür werden im Folgenden die Umgebungen \env{Preamble}, \env{Trunk} und +% \env{Hint} sowie daraus abgeleitet Varianten definiert, womit sich die Angabe +% und Erläuterung der Quelltexte im Tutorial logisch strukturieren lässt und +% dennoch die notwendige Ordnung dieser für das Copy"~\&"~Paste"~Beispiel +% aufrechterhalten werden kann. Hierfür zeichnen die beiden Umgebungen +% \env{Preamble} und \env{Trunk} und deren Derivate verantwortlich. Die +% Umgebung \env{Hint} steht für zusätzliche Erläuterungen bereit, welche jedoch +% nicht in das Copy"~\&"~Paste"~Beispiel übernommen werden. +% +% \begin{macro}{\tud@write@a} +% \changes{v2.02}{2014/10/22}{neu}^^A +% \begin{macro}{\tud@write@b} +% \changes{v2.02}{2014/11/02}{neu}^^A +% \begin{macro}{\tud@read} +% \changes{v2.02}{2014/08/19}{neu}^^A +% Für die Erstellung der Indexe wird zum Sortieren das Programm \app{texindy} +% genutzt. Für dieses wird eine eigene Stildatei verwendet, welche zur Laufzeit +% erzeugt wofür zuerst ein Ausgabestream reserviert wird. +% \begin{macrocode} +\newcommand*\tud@write@a{} +\newwrite\tud@write@a +% \end{macrocode} +% Für die Tutorials werden später zusätzlich noch ein weiterer Ausgabe- sowie +% ein Eingabestream benötigt, die hier gleich mit initialisiert werden. +% \begin{macrocode} +%<*package> +\newcommand*\tud@write@b{} +\newwrite\tud@write@b +\newcommand*\tud@read{} +\newread\tud@read +%</package> +% \end{macrocode} +% \end{macro}^^A \tud@read +% \end{macro}^^A \tud@write@b +% \end{macro}^^A \tud@write@a +% +% \subsection{Einbinden von Quelltextauszügen} +% +% Sowohl im Handbuch als auch in den Tutorials werden Quelltextauszüge für das +% bessere Verständnis des Anwenders angegeben. Um diese darzustellen wird das +% Paket \pkg{listings} verwendet. +% \begin{macrocode} +\RequirePackage{listings}[2014/03/04] +\lstdefinestyle{tudscr}{% + basicstyle=\ttfamily\ifdef{\setstretch}{\setstretch{1}}{},% + keywordstyle=,% + columns=fullflexible,keepspaces,% + aboveskip=\smallskipamount,% + belowskip=\smallskipamount,% + language=[LaTeX]TeX,% + texcl,% +} +% \end{macrocode} +% +% \iffalse +%<*class> +% \fi +% +% \begin{environment}{Code} +% \begin{macro}{\tud@currentHref} +% Folgend werden Befehle und Umgebungen für die Darstellung von Quelltexten im +% Handbuch definiert. Mit dieser Umgebung können kurze Quelltextbeispiele +% ausgegeben werden. Sicherlich sinnvoll ist, die \env{Code}-Umgebung innerhalb +% von \env{Example} oder \env{quoting} zu verwenden, um den Quelltext etwas +% abzuheben. +% \begin{macrocode} +\lstnewenvironment{Code}[1][]{\lstset{style=tudscr,#1}}{} +% \end{macrocode} +% Innerhalb der Umgebung \env{Code} wird \cs{@currentHref} unerwünschter Weise +% geändert. Um dies zu vermeiden, wird dieser Befehl gesichert und anschließend +% zurückgesetzt. +% \begin{macrocode} +\newcommand*\tud@currentHref{} +\BeforeBeginEnvironment{Code}{\global\let\tud@currentHref\@currentHref} +\AfterEndEnvironment{Code}{\global\let\@currentHref\tud@currentHref} +% \end{macrocode} +% \end{macro}^^A \tud@currentHref +% \end{environment}^^A Code +% +% \iffalse +%</class> +% \fi +% +% \subsection{Kompilieren von externen Dateien und Querverweise auf diese} +% +% Das Paket \pkg{filemod} wird genutzt, um externer Dateien nur zu kompilieren, +% wenn dies aufgrund einer Änderung auch notwendig ist. +% \begin{macrocode} +\RequirePackage{filemod}[2011/09/19] +% \end{macrocode} +% Um \cs{ShellEscape} sowohl für Windows als auch für unixoide Betriebssysteme +% nutzen zu können, wird das Paket \pkg{ifplatform} geladen. +% \begin{macrocode} +\RequirePackage{ifplatform}[2010/10/22] +% \end{macrocode} +% \begin{macro}{\tud@shellescape@wrn} +% \changes{v2.02}{2014/10/14}{neu}^^A +% Dieses Makro wird verwendet, wenn eine gesuchte Datei nicht gefunden wurde, +% weil das Dokument noch nicht mit dem Schalter \file{-{}-shell-escape} +% kompiliert wurde. +% \begin{macrocode} +\newcommand*\tud@shellescape@wrn[1]{% +%<*class> + \ClassWarning{tudscrmanual}% +%</class> +%<*package> + \PackageWarning{tudscrtutorial}% +%</package> + {% + File `#1' is missing!\MessageBreak% + You have to recompile this document with\MessageBreak% + activated shell escape option% + }% +} +% \end{macrocode} +% \end{macro}^^A \tud@shellescape@wrn +% \begin{macro}{\tud@latex@ext} +% \changes{v2.06}{2019/06/21}{neu}^^A +% Für das verschachtelte Aufrufen von \app{pdflatex} bzw. \app{lualatex}. +% \begin{macrocode} +\newcommand*\tud@latex@ext{} +\ifpdftex% + {\def\tud@latex@ext{pdflatex\space}}% + {\def\tud@latex@ext{lualatex\space}}% +% \end{macrocode} +% \end{macro}^^A \tud@latex@ext +% \begin{macro}{\Tutorial} +% \changes{v2.02}{2014/08/22}{neu}^^A +% \changes{v2.02}{2014/10/22}{Reimplementierung}^^A +% \begin{macro}{\hypertut} +% \changes{v2.02}{2014/09/02}{neu}^^A +% Die gegebenenfalls notwendige Kompilierung und die Referenzierung eines +% Tutorials aus dem Handbuch erfolgt mit \cs{Tutorial}. Außerdem erfolgt mit +% \cs{hypertut} ein verlinkter Eintrag in den Index. +% \begin{macrocode} +%<*class> +\newrobustcmd*\hypertut[2]{% + \hyperref{tutorials/#1.pdf}{#1}{tutorials:#1}{\File*{#1.pdf}#2}% +} +\NewDocumentCommand\Tutorial{s m !d||}{% + \ifnum\pdf@shellescape=\@ne\relax% +% \end{macrocode} +% Um mit den verschachtelten Aufrufen von \app{pdflatex} umgehen zu können, +% wird das ganze Prozedere in ein Skript ausgelagert. Somit können die Aufrufe +% von \app{pdflatex} für die Tutorials aus dem entsprechenden Ordner und mit +% den notwendigen Optionen erfolgen. +% \begin{macrocode} + \filemodCmp{tutorials/#2.pdf}{tutorials/#2.tex}{}{% + \let\@tempa\@empty% + \ifdef{\tudfinalflag}{\appto\@tempa{\def\noexpand\tudfinalflag{}}}{}% + \ifdef{\tudprintflag}{\appto\@tempa{\def\noexpand\tudprintflag{}}}{}% + \appto\@tempa{\noexpand\input{#2.tex}}% + \def\@tempb##1{% + \immediate\openout\tud@write@a=tutorials.sh\relax% + \immediate\write\tud@write@a{cd tutorials^^J##1}% + \immediate\closeout\tud@write@a% +% \end{macrocode} +% Hier erfolgt die Unterscheidung der Befehle für die unterschiedlichen OS. +% \begin{macrocode} + \ifwindows% + \ShellEscape{rename tutorials.sh tutorials.bat}% + \ShellEscape{tutorials.bat}% + \ShellEscape{del tutorials.bat}% + \else% + \ShellEscape{bash tutorials.sh}% + \ShellEscape{rm tutorials.sh}% + \fi% + }% + \@tempb{\tud@latex@ext -shell-escape "\@tempa"}% + \IfFileExists{tutorials/#2.bcf}{\@tempb{biber #2}}{}% + \@tempb{% + \tud@latex@ext "\@tempa"^^J% + \tud@latex@ext -shell-escape "\@tempa"^^J% + \tud@latex@ext -shell-escape "\@tempa"% + }% + }% + \fi% +% \end{macrocode} +% Hyperlink und Indexeintrag. +% \begin{macrocode} + \IfFileExists{tutorials/#2.pdf}{% + \hypertut{#2}{}% + }{% + \File*{#2.pdf}% + \tud@shellescape@wrn{tutorials/#2.pdf}% + }% + \IfBooleanF{#1}{% + \index[files]{\hypertut{#2}{\suffix{Tutorial}}\IfValueT{#3}{|#3}}% + }% +} +%</class> +% \end{macrocode} +% Der Befehl für die Querverweise innerhalb von Tutorials. +% \begin{macrocode} +%<*package> +\newcommand*\Tutorial[1]{\href{#1.pdf}{\textsbn{#1.pdf}}} +%</package> +% \end{macrocode} +% \end{macro}^^A \hypertut +% \end{macro}^^A \Tutorial +% \begin{macro}{\IncludeExample} +% \changes{v2.02}{2014/07/25}{Skalierung der eingefügten Seiten}^^A +% Mit diesem Befehl wird eine \LaTeX-Datei ggf. übersetzt und anschließend als +% PDF"~Datei wieder eingebunden. Zuvor wird der dazugehörige Quelltext mittels +% \cs{lstinputlisting} im Dokument ausgegeben. Dieser Befehl wird lediglich für +% die Klasse \cls{tudscrmanual} benötigt. +% \begin{macrocode} +%<*class> +\newcommand*\IncludeExample[1]{% + \lstinputlisting[style=tudscr]{examples/#1}% +% \end{macrocode} +% Die Beispiele werden nur erneut kompiliert, wenn sich diese geändert haben +% oder noch gar kein entsprechendes PDF"~Dokument existiert. +% \begin{macrocode} + \ifnum\pdf@shellescape=\@ne\relax% + \filemodCmp{examples/#1.pdf}{examples/#1.tex}{}{% + \ShellEscape{% + \tud@latex@ext -output-directory examples examples/#1.tex^^J% + \tud@latex@ext -output-directory examples examples/#1.tex% + }% + }% +% \end{macrocode} +% Sollte es eine spezielle Version eines beispiels für die Druckausgabe geben, +% wird auch dieses kompiliert. +% \begin{macrocode} + \filemodCmp{examples/#1_print.pdf}{examples/#1_print.tex}{}{% + \ShellEscape{% + \tud@latex@ext -output-directory examples examples/#1_print.tex^^J% + \tud@latex@ext -output-directory examples examples/#1_print.tex% + }% + }% + \fi% +% \end{macrocode} +% Ist die gesuchte Datei vorhanden, wird diese auch eingebunden. Andernfalls +% wird eine Warnung mit dem Hinweis auf die notwendige Verwendung von +% \app{pdflatex} mit dem Schalter \file{-{}-shell-escape} erzeugt. +% \begin{macrocode} + \def\@tempa{examples/#1.pdf}% + \ifdef{\tudprintflag}{% + \IfFileExists{examples/#1_print.pdf}{\def\@tempa{examples/#1_print.pdf}}{}% + }{}% + \IfFileExists{\@tempa}{% + \edef\@tempa{% + \noexpand\includepdf[% + pages=-,noautoscale,frame,keepaspectratio,pagecommand={},% + height=\noexpand\textheight,width=\noexpand\textwidth,offset=5mm 0mm% + ]{\@tempa}% + }% + \@tempa% + }{% + \tud@shellescape@wrn{\@tempa}% + }% +} +%</class> +% \end{macrocode} +% \end{macro}^^A \IncludeExample +% +% \iffalse +%<*package> +% \fi +% +% \begin{macro}{\tud@tut@temp} +% \changes{v2.05}{2016/05/01}{neu}^^A +% \begin{macro}{\tud@tut@readtostream} +% \changes{v2.02}{2014/12/16}{neu}^^A +% \begin{macro}{\tud@tut@append} +% \changes{v2.02}{2014/08/19}{neu}^^A +% Bei den Tutorials soll zum Schluss ein komplett kompilierbares Beispiel für +% Copy~\&~Paste gegeben werden. Um dieses zusammenzubauen, werden alle im +% Dokument innerhalb der Varianten der \env{Trunk}-Umgebungen gegebenen +% Codefragmente zusammengesetzt. Um die Quelltexte einlesen und verarbeiten zu +% können, werden zwei Eingabe- sowie ein Ausgabestream benötigt, welche bereits +% zuvor initialisiert wurden. +% +% Mit \cs{tud@tut@readtostream} wird der Inhalt der Datei im ersten Argument +% in den Ausgabestream des zweiten Argumentes geschrieben. Dies wird durch +% \cs{tud@tut@append} genutzt. +% \begin{macrocode} +\newcommand*\tud@tut@temp{} +\edef\tud@tut@temp{\@currname-temp} +\newcommand*\tud@tut@readtostream[2]{% + \begingroup% + \endlinechar=\m@ne\relax% + \openin\tud@read=#1% +% \end{macrocode} +% Der Schalter \cs{if@tempswa} wird verwendet, um unnötige Leerzeilen in der +% Ausgabedatei zu entfernen. Wurde eine nicht leere Zeile gefunden, wird diese +% auf jeden Fall geschrieben, indem \cs{@tempswatrue} gesetzt wird. Eine leere +% Zeile wird~-- bis auf den Sonderfall, dass es sich um die letzte Zeile in der +% Datei handelt~-- zunächst nicht weiter beachtet. Im Zweifelsfall wird diese +% (erste) Leerzeile geschrieben. +% \begin{macrocode} + \@tempswafalse% + \loop\unless\ifeof\tud@read% + \readline\tud@read to\tud@reserved% + \ifx\tud@reserved\@empty% + \ifeof\tud@read\@tempswafalse\fi% + \else% + \@tempswatrue% + \fi% +% \end{macrocode} +% Hier erfolgt das eigentliche Schreiben im selektierten Stream. +% \begin{macrocode} + \if@tempswa% + \immediate\write#2{\expandonce\tud@reserved}% + \fi% +% \end{macrocode} +% Im Nachgang wird überprüft, ob die aktuell geschriebene Zeile leer war. Ist +% dies der Fall, so wird \cs{@tempswafalse} gesetzt, um eine etwaig folgende +% Leerzeile nicht in die Ausgabedatei zu schrieben. +% \begin{macrocode} + \ifx\tud@reserved\@empty\@tempswafalse\fi% + \repeat% + \closein\tud@read% + \endgroup% +} +% \end{macrocode} +% Der innerhalb der Umgebungen \env{Preamble} und \env{Trunk}~-- sowie deren +% Derivaten~-- angegebene Inhalt wird beim Schließen dieser Umgebungen in die +% Hilfsdatei \cs{tud@tut@temp.tex} zwischengespeichert. Mit \cs{tud@tut@append} +% wird der Inhalt dieser Datei ausgelesen und den Hilfsdateien +% \cs{tud@tut@temp-preamble.tex} respektive \cs{tud@tut@temp-trunk.tex} +% angehangen und damit gesichert, um die jeweiligen Quelltextauszüge aus dem +% Tutorial für die Präambel sowie den Dokumentteil trennen beziehungsweise +% sortieren zu können. +% \begin{macrocode} +\newcommand*\tud@tut@append[1]{% + \ifstr{#1}{preamble}{% + \tud@tut@readtostream{\tud@tut@temp.tex}{\tud@write@a}% + }{% + \ifstr{#1}{trunk}{% + \tud@tut@readtostream{\tud@tut@temp.tex}{\tud@write@b}% + }{% + \tud@tut@readtostream{\tud@tut@temp.tex}{#1}% + }% + }% +} +% \end{macrocode} +% \end{macro}^^A \tud@tut@append +% \end{macro}^^A \tud@tut@readtostream +% \end{macro}^^A \tud@tut@temp +% \begin{macro}{\StartTutorial} +% \changes{v2.02}{2014/08/21}{neu}^^A +% \begin{macro}{\FinishTutorial} +% \changes{v2.02}{2014/08/21}{neu}^^A +% Mit \cs{StartTutorial} wird ein Hyperlink für den Querverweis aus dem +% Handbuch definiert. Außerdem wird gleich der Titel und~-- falls im optionalen +% Argument angegeben~-- eine Zusammenfassung gesetzt. Die Sternversion gibt +% nach der optionalen Beschreibung einen einleitenden Satz zur Dokumnentklasse +% und sinnvollen Paketen an. Diese sollten direkt nach \cs{StartTutorial} in +% der \env{Preamble}-Umgebung angegeben werden. +% \begin{macrocode} +\TUDoptions{headingsvskip=-10ex} +\newcommand\StartTutorial[1][]{% + \immediate\openout\tud@write@a=\tud@tut@temp-preamble.tex\relax% + \immediate\openout\tud@write@b=\tud@tut@temp-trunk.tex\relax% + \immediate\write\tud@write@b{^^J\string\begin{document}^^J}% + \Hy@raisedlink{\hyperdef{\jobname}{tutorials:\jobname}{}}% + \faculty{}% + \maketitle% + \ifblank{#1}{}{% + \noindent% + \begin{abstract}% + \noindent#1% + \end{abstract}% + \medskip% + }% + \noindent\ignorespaces% +} +% \end{macrocode} +% Der Befehl \cs{FinishTutorial} schleißt den noch offenen Ausgabestream und +% gibt den vorgestellten Quelltext vollständig aus. +% \begin{macrocode} +\newcommand\FinishTutorial[1][]{% + \immediate\write\tud@write@b{^^J\string\end{document}^^J}% + \immediate\closeout\tud@write@b% + \immediate\closeout\tud@write@a% + \immediate\openout\tud@write@a\jobname-example.tex\relax% + \tud@tut@readtostream{\tud@tut@temp-preamble.tex}{\tud@write@a}% + \tud@tut@readtostream{\tud@tut@temp-trunk.tex}{\tud@write@a}% + \immediate\closeout\tud@write@a% + \clearpage% + \addsec{Copy\nobreakspace\&\nobreakspace{}Paste}% + \thispagestyle{empty}% + \pagestyle{empty}% + Zum Ende des Dokumentes wird das vorgestellte Tutorial als \"ubersetzbarer + Quelltext ausgegeben, um dieses via Copy~\&~Paste verwenden und alle Punkte + nachvollziehen zu k\"onnen. Bitte beachten Sie, dass~-- abh\"angig vom + genutzten PDF-Betrachter~-- beim Kopieren die dargestellten Einz\"uge und + Abs\"atze m\"oglicherweise verloren gehen k\"onnen. Dies kann insbesondere + aufgrund fehlender Leerzeilen zu einem unvorteilhaften Ausgabeergebnis + f\"uhren. Alternativ finden Sie den folgenden \hologo{LaTeX}-Quelltext auch + im Pfad \Path{\PName{texmf}/source/latex/tudscr/doc/examples/} als Datei + \File{\jobname-example.tex}. \par #1% + % + \begin{quoting}[rightmargin=0pt]% + \lstinputlisting[style=tudscr]{\jobname-example.tex}% + \end{quoting}% + % +% \end{macrocode} +% Falls es möglich ist, werden nach dem Durchlauf alle nicht mehr benötigten +% Hilfsdateien gelöscht. +% \begin{macrocode} + \ifnum\pdf@shellescape=\@ne\relax% + \ifwindows% + \def\@tempa{del}% + \else% + \def\@tempa{rm}% + \fi% + \ShellEscape{\@tempa\space\tud@tut@temp*.*}% + \fi% +} +% \end{macrocode} +% \end{macro}^^A \FinishTutorial +% \end{macro}^^A \StartTutorial +% \begin{macro}{\CodePreamble} +% \changes{v2.02}{2014/08/20}{neu}^^A +% \begin{macro}{\Code@Preamble} +% \changes{v2.02}{2014/10/22}{neu}^^A +% \begin{macro}{\CodeHook} +% \changes{v2.02}{2014/10/11}{neu}^^A +% \begin{macro}{\Code@Hook} +% \changes{v2.02}{2014/10/11}{neu}^^A +% Bereitstellung von Hilfsmakros für die formatierte Ausgabe von Quelltexten. +% \begin{macrocode} +\newcommand\Code@Preamble{} +\let\Code@Preamble\relax +\newcommand\CodePreamble[1]{% + \long\gdef\Code@Preamble{% + \hskip.5\leftmargin\textit{Die resultierende Ausgabe:}\space#1% + }% +} +\newcommand*\Code@Hook{} +\let\Code@Hook\relax +\newcommand*\CodeHook[1]{\gdef\Code@Hook{#1}} +% \end{macrocode} +% \end{macro}^^A \Code@Hook +% \end{macro}^^A \CodeHook +% \end{macro}^^A \Code@Preamble +% \end{macro}^^A \CodePreamble +% \begin{macro}{\StandaloneFile} +% \changes{v2.02}{2014/08/19}{neu}^^A +% \begin{macro}{\StandaloneDate} +% \changes{v2.05}{2015/11/18}{neu}^^A +% Die Umgebungen \env{Trunk!} und \env{Hint!} erzeugen nach der Ausgabe des +% Quelltextes mit dem Makro \cs{tud@tut@pdf} eine PDF-Datei, welche mit +% \cs{IncludeStandalone} in das Tutorial eingebunden werden kann. +% \begin{macrocode} +\newcommand*\StandaloneFile{} +\let\StandaloneFile\relax +\newcommand*\StandaloneDate{} +% \end{macrocode} +% \end{macro}^^A \StandaloneDate +% \end{macro}^^A \StandaloneFile +% \begin{macro}{\tud@tut@pre} +% \changes{v2.02}{2014/08/19}{neu}^^A +% \begin{macro}{\tud@tut@post} +% \changes{v2.02}{2014/08/19}{neu}^^A +% Dies sind Hilfsmakros, welche zu Beginn und Ende der Quelltextumgebungen +% \env{Preamble}, \env{Trunk} und \env{Hint} für das Sichern der Inhalte in +% eine Hilfsdatei verantwortlich sind, wofür die \env{filecontents}-Umgebung +% genutzt wird. +% \begin{macrocode} +\newcommand*\tud@tut@pre{% + \csuse{filecontents*}{\tud@tut@temp.tex}% +} +\newcommand*\tud@tut@post{% + \csuse{endfilecontents*}% +} +% \end{macrocode} +% \end{macro}^^A \tud@tut@post +% \end{macro}^^A \tud@tut@pre +% Die nachfolgenden Umgebungen verwenden die beiden, gerade zuvor eingeführten +% Hilfsmakros \cs{tud@tut@pre} und \cs{tud@tut@post}, welche den gegebenen +% Inhalt in die temporäre Datei \file{\string\tud@tut@temp.tex} schreiben. Die +% im Dokument in den Umgebungen gesetzten Quelltextauszüge werden mit dem Makro +% \cs{tud@tut@append}~-- abhängig vom gegebenen Argument~-- zusätzlich für ein +% Copy"~\&"~Paste"~Beispiel in \file{\string\tud@tut@temp-preamble.tex} oder +% \file{\string\tud@tut@temp-trunk.tex} gepsiechert. Die damit gesammelten +% Inhalte werden am Ende mit \cs{FinishTutorial} ausgegeben. +% \begin{environment}{Preamble} +% \changes{v2.02}{2014/11/02}{neu}^^A +% \begin{environment}{Preamble*} +% \changes{v2.02}{2014/11/03}{neu}^^A +% \begin{environment}{Preamble+} +% \changes{v2.02}{2014/11/03}{neu}^^A +% Die Umgebung \env{Preamble} dient für die Ausgabe von Quelltextauszügenen, +% welche in einem \LaTeXe-Dokument in der Präambel verwendet werden müssen oder +% sollten. Die in ihr gesetzten Inhalte werden für das Copy"~\&"~Paste-Beispiel +% vor den Inhalten aus der Umgebung \env{Trunk} ausgegeben. Die Sternversion +% führt den Inhalt zusätzlich im Dokument aus. Die Pluszechen"=Version fügt dem +% Ausgabestream ihren Inhalt hinzu, ohne das dieser ausgegeben oder ausgeführt +% wird. +% \begin{macrocode} +\newenvironment{Preamble}{\tud@tut@pre}{% + \tud@tut@post% + \tud@tut@append{preamble}% + \gdef\@tempa{% + \tud@tut@lst% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +\newenvironment{Preamble*}{\tud@tut@pre}{% + \tud@tut@post% + \tud@tut@append{preamble}% + \gdef\@tempa{% + \tud@tut@lst% + \tud@tut@input% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +\newenvironment{Preamble+}{\tud@tut@pre}{% + \tud@tut@post% + \tud@tut@append{preamble}% + \gdef\@tempa{% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +% \end{macrocode} +% \end{environment}^^A Preamble+ +% \end{environment}^^A Preamble* +% \end{environment}^^A Preamble +% \begin{environment}{Trunk} +% \changes{v2.02}{2014/08/16}{neu}^^A +% \begin{environment}{Trunk*} +% \changes{v2.02}{2014/08/19}{neu}^^A +% \begin{environment}{Trunk+} +% \changes{v2.02}{2014/11/03}{neu}^^A +% \begin{environment}{Trunk!} +% \changes{v2.02}{2014/10/07}{neu}^^A +% Die Umgebung \env{Trunk} dient zur Ausgabe von exemplarischen Quelltexten, +% welche in einem \LaTeXe-Dokument innerhalb der \env{document}-Umgebung +% verwendet werden müssen oder sollten. Für das Copy"~\&"~Paste-Beispiel werden +% die gegebenen Inhalte nach den Inhalten aus der Umgebung \env{Preamble} +% ausgegeben. Die Sternversion der Umgebung führt ihren Inhalt zusätzlich im +% Dokument aus. Die Pluszeichen"=Version fügt dem Ausgabestream ihren Inhalt +% hinzu, ohne diesen auszugeben oder auszuführen. Die Ausrufezeichen"=Version +% fügt den Quelltext im Dokument ein und führt diesen zusätzlich in einer +% separaten Datei mit einem minimalen Dokumentkörper aus, um daraus eine +% PDF-Datei zu erzeugen, welche im Nachhinein mit \cs{IncludeStandalone} als +% Grafik eingebunden werden kann. Dies ist für Quelltextabschnitte gedacht, +% deren Ausgabe zu groß ist, um diese direkt anzuzeigen und dennoch dargestellt +% werden sollen. +% \begin{macrocode} +\newenvironment{Trunk}{\tud@tut@pre}{% + \tud@tut@post% + \tud@tut@append{trunk}% + \gdef\@tempa{% + \tud@tut@lst% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +\newenvironment{Trunk*}{\tud@tut@pre}{% + \tud@tut@post% + \tud@tut@append{trunk}% + \gdef\@tempa{% + \tud@tut@lst% + \tud@tut@input% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +\newenvironment{Trunk+}{\tud@tut@pre}{% + \tud@tut@post% + \tud@tut@append{trunk}% + \gdef\@tempa{% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +\newenvironment{Trunk!}[1]{% + \gdef\StandaloneFile{#1}% + \tud@tut@pre% +}{% + \tud@tut@post% + \tud@tut@append{trunk}% + \gdef\@tempa{% + \tud@tut@lst% + \tud@tut@pdf% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +% \end{macrocode} +% \end{environment}^^A Trunk! +% \end{environment}^^A Trunk+ +% \end{environment}^^A Trunk* +% \end{environment}^^A Trunk +% \begin{environment}{Hint} +% \changes{v2.02}{2014/09/16}{neu}^^A +% \begin{environment}{Hint*} +% \changes{v2.02}{2014/10/13}{neu}^^A +% \begin{environment}{Hint?} +% \changes{v2.02}{2014/12/09}{neu}^^A +% \begin{environment}{Hint!} +% \changes{v2.02}{2014/11/13}{neu}^^A +% Um Quelltextausschnitte zur weiterführenden Information anzugeben, wird die +% Umgebung \env{Hint} definiert. Der Inhalt wird ausgegben und~-- falls die +% Sternversion genutzt wurde~-- auch ausgeführt, allerdings nicht in das +% Copy"~\&"~Paste"~Beispiel übernommen. Ansonsten entsprechen alle Umgebungen +% in ihren Eigenschaften den äquivalenten \env{Trunk}-Umgebungen. Die Version +% mit Fragezeichen ist für Quelltextauszüge gedacht, die ungeprüft \emph{vor} +% dessen Ausgabe ausgeführt werden sollen. +% \begin{macrocode} +\newenvironment{Hint}{\tud@tut@pre}{% + \tud@tut@post% + \gdef\@tempa{% + \tud@tut@lst% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +\newenvironment{Hint*}{\tud@tut@pre}{% + \tud@tut@post% + \gdef\@tempa{% + \tud@tut@lst% + \tud@tut@input% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +\newenvironment{Hint?}{\tud@tut@pre}{% + \tud@tut@post% + \gdef\@tempa{% + \InputCode% + \tud@tut@lst% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +\newenvironment{Hint!}[1]{% + \gdef\StandaloneFile{#1}% + \tud@tut@pre% +}{% + \tud@tut@post% + \gdef\@tempa{% + \tud@tut@lst% + \tud@tut@pdf% + \global\let\Code@Preamble\relax% + }% + \aftergroup\@tempa% +} +% \end{macrocode} +% \end{environment}^^A Hint! +% \end{environment}^^A Hint? +% \end{environment}^^A Hint* +% \end{environment}^^A Hint +% \begin{macro}{\tud@tut@lst} +% \changes{v2.02}{2014/10/07}{neu}^^A +% Damit wird der Quelltext eingezogen ausgegeben. +% \begin{macrocode} +\newcommand*\tud@tut@lst{% + \begin{quoting}[rightmargin=0pt]% + \lstinputlisting[style=tudscr]{\tud@tut@temp.tex}% + \end{quoting}% +} +% \end{macrocode} +% \end{macro}^^A \tud@tut@lst +% \begin{macro}{\tud@tut@input} +% \changes{v2.02}{2014/10/13}{neu}^^A +% Für die Ausgabe des Quelltextergebnisses erfolgt ein linker Einzug. Außerdem +% werden unter anderem abhängig von der Verwendung eines erklärenden Textes die +% eingefügten vertikalen Abstände angepasst. +% \begin{macrocode} +\newcommand*\tud@tut@input{% +% \end{macrocode} +% Nach dem Ausführen des ersten Argumentes von \cs{@tempa} wird geprüft, ob +% dieses überhaupt eine sichtbare Ausgabe erzeugt hat. Nur für diesen Fall wird +% nach dieser vertikaler Leerraum eingefügt. Der Anfang entspricht prinzipiell +% dem Standardbefehl \cs{settoheight}, jedoch wird im Inneren zusätzlich eine +% \cs{vbox} verwendet, um damit auch mathematische Umgebungen testen zu können. +% Das Ganze findet innerhalb einer Gruppierung statt, um keine Änderungen zu +% erzeugen. +% \begin{macrocode} + \def\@tempa##1##2{% + ##1% + \begingroup% + ##2% + \setbox\@tempboxa\hbox{\vbox{##1}}% + \@tempdima=\ht\@tempboxa% + \setbox\@tempboxa\box\voidb@x% + \ifdim\@tempdima>\z@\relax% + \endgraf% + \vspace{\medskipamount}% + \noindent\ignorespaces% + \fi% + \endgroup% + }% +% \end{macrocode} +% Da aufgrund der Verwendung der \env{filecontents}-Umgebung ein optionales +% Argument für alle Abwandlungen der Quelltextumgebungen nicht möglich ist, +% wird \cs{CodePreamble} bereitgestellt, womit der Ausgabe ein erläuternder +% Text vorangestellt werden kann. +% \begin{macrocode} + \@tempa{\Code@Preamble}{}% + \setlength\@tempdimc{\leftskip}% + \setlength\leftskip{\leftmargin}% +% \end{macrocode} +% Durch die zweimalige Verwendung von \file{\string\tud@tut@temp.tex}~-- einmal +% direkt und einmal innerhalb einer Box~-- können darin verwendete Befehle wie +% \cs{newcommand} zu Fehler führen. Mit dem Makro \cs{CodeHook} lassen sich +% diese Konflikte durch eine lokale Redefinition ebensolcher Befehle auflösen +% (bspw. \cs{let}\cs{newcommand}\cs{renewcommand}). +% \begin{macrocode} + \@tempa{\input{\tud@tut@temp.tex}}{\Code@Hook}% + \global\let\Code@Hook\relax% + \setlength\leftskip{\@tempdimc}% + \noindent\ignorespaces% +} +% \end{macrocode} +% \end{macro}^^A \tud@tut@input +% \begin{macro}{\InputCode} +% \changes{v2.02}{2014/10/21}{neu}^^A +% Mit \cs{InputCode} kann der Inhalt der letzen \env{Trunk}-Umgebung +% direkt ausgeführt werden, ohne diesen zuvor mit \cs{tud@tut@input} zu prüfen +% und zu formatieren. +% \begin{macrocode} +\newcommand*\InputCode{\input{\tud@tut@temp.tex}} +% \end{macrocode} +% \end{macro}^^A \InputCode +% \begin{macro}{\tud@tut@pdf} +% \changes{v2.02}{2014/10/22}{neu}^^A +% Die Umgebungen \env{Trunk!} und \env{Hint!} verwenden nach der Ausgabe des +% Quelltextes diesen abermals, um daraus eine PDF-Datei zu erzeugen. Dafür wird +% eine temporäre \LaTeX-Datei mithilfe einer \env{filecontents}-Umgebung +% erzeugt. Diese bindet die mit \env{Trunk!} erzeugte Datei ein und wird +% anschließend via \cs{ShellEscape} kompiliert. Dabei sollte man sich nicht von +% der doppelten Verwendung von \cs{jobname} verwirren lassen. Der Dateiname der +% temporär erzeugten \LaTeX-Datei ist abhängig vom gesetzten Tutorial. Beim +% Aufruf dieser wird über die Optionen von \app{pdflatex} der verwendete +% \cs{jobname} angepasst (siehe \cs{tud@tut@pdf}). +% \begin{macrocode} +\IfFileExists{\tud@tut@temp-standalone.tex}{\@tempswafalse}{\@tempswatrue} +\if@tempswa% +\begin{filecontents*}{\tud@tut@temp-standalone.tex} +\documentclass[english,ngerman]{tudscrreprt} +\ifpdftex{ + \usepackage[T1]{fontenc} + \usepackage[ngerman=ngerman-x-latest]{hyphsubst} +}{ + \usepackage{fontspec} +} +\usepackage{babel} +\usepackage{tudscrsupervisor} +\usepackage{isodate} +\usepackage{enumitem} +\setlist{noitemsep} +\begin{document} +\ifdefvoid{\StandaloneDate}{}{\date{\StandaloneDate}}% +\input{\jobname.tex}% +\end{document} +\end{filecontents*} +\fi +% \end{macrocode} +% Der Quelltext aus den Umgebungen \env{Trunk!} und \env{Hint!} wird~-- wie bei +% allen anderen \env{Trunk}-Derivaten~-- in \file{\string\tud@tut@temp.tex} +% gesichert. Beim Aufruf von \app{pdflatex} wird durch die Nutzung der Option +% \file{-jobname=\string\tud@tut@temp} die Definition von \cs{jobname} in der +% aufgerufenen Datei \file{\string\tud@tut@temp-standalone.tex} überschrieben +% und der Inhalt von \file{\string\tud@tut@temp.tex} wie gewünscht eingebunden +% und kompiliert. Damit die so erstellte PDF-Datei mit \cs{IncludeStandalone} +% im weiteren Verlauf in das Tutorial eingebunden werden kann, wird diese +% außerdem noch in \cs{\meta{Argument}-temp.pdf} umbenannt. Das Makro +% \cs{StandaloneDate} wird auf das Datum der Master-Datei gesetzt, damit das +% voreingestellte Datum der erzeugten Datei angepasst werden kann. +% \begin{macrocode} +\newcommand*\tud@tut@pdf{% + \ifnum\pdf@shellescape=\@ne\relax% + \filemodCmp{\jobname-standalone-\StandaloneFile.pdf}{\jobname.tex}{}{% + \begingroup% + \let\printdate\@firstofone% + \edef\@tempa{\expandonce\@date}% + \def\@tempb{\today}% + \ifx\@tempa\@tempb\relax% + \let\@tempb\@empty% + \else% + \edef\@tempb{\etex@unexpanded{\def\StandaloneDate}{\@date}}% + \fi% + \edef\@tempa{% + \tud@latex@ext -jobname=\tud@tut@temp\space% + "\noexpand\unexpanded{\expandonce\@tempb\noexpand\input}% + {\tud@tut@temp-standalone.tex}"% + }% + \ShellEscape{\@tempa^^J\@tempa^^J\@tempa}% + \ifwindows% + \def\@tempa{rename}% + \else% + \def\@tempa{mv}% + \fi% + \ShellEscape{% + \@tempa\space\tud@tut@temp.pdf\space% + \jobname-standalone-\StandaloneFile.pdf% + }% + \endgroup% + }% + \fi% + \global\let\StandaloneFile\relax% +} +% \end{macrocode} +% \end{macro}^^A \tud@tut@pdf +% \begin{macro}{\IncludeStandalone} +% \changes{v2.02}{2014/09/10}{neu}^^A +% Der Befehl \cs{IncludeStandalone} bindet die durch \env{Trunk!} generierten +% PDF-Dateien ein. Das angehängte optionale Argument dient zur Angabe der +% einzubindenden Seiten der PDF-Datei, wobei diese automatisch auf die passende +% Breite skaliert werden. +% \begin{macrocode} +\NewDocumentCommand\IncludeStandalone{o m !O{1}}{% + \IfFileExists{\jobname-standalone-#2.pdf}{% + \@tempcnta\z@% + \@for\@tempa:=#3\do{\advance\@tempcnta\@ne}% + \ifnum\@tempcnta>\z@\relax% + \setlength\@tempdima{\textwidth}% + \divide\@tempdima\@tempcnta% + \advance\@tempcnta\m@ne% + \multiply\@tempcnta 2% + \addtolength\@tempdima{-\@tempcnta\tabcolsep}% + \@for\@tempa:=#3\do{% + \advance\@tempcnta\m@ne% + \edef\@tempb{% + keepaspectratio,page=\@tempa,width=\the\@tempdima,% + \IfValueT{#1}{#1}% + }% + \fbox{% + \expandafter\includegraphics\expandafter[\@tempb]{% + \jobname-standalone-#2.pdf% + }% + }% + \ifnum\@tempcnta>\z@\relax\hfill\fi% + }% + \fi% + }{% + \tud@shellescape@wrn{\jobname-standalone-#2.pdf}% + }% +} +% \end{macrocode} +% \end{macro}^^A \IncludeStandalone +% +% \iffalse +%</package> +% \fi +% +% \subsection{Automatische Erstellung von \pkg{pstricks}-Grafiken} +% +% Falls innerhalb eines Tutorials das Paket \pkg{pstricks} verwendet wird, muss +% dafür Sorge getragen werden, dass die automatische Kompilierung reibungslos +% mit \pkg{auto-pst-pdf} funktioniert. +% \begin{macrocode} +%<*package> +\AfterPackage*{pstricks}{% + \ifnum\pdf@shellescape=\@ne\relax% + \filemodCmp{\jobname-pics.pdf}{\jobname.tex}{% + \PassOptionsToPackage{off}{auto-pst-pdf}% + }{}% + \else% + \PassOptionsToPackage{off}{auto-pst-pdf}% + \fi% + \RequirePackage{auto-pst-pdf}[2009/04/26]% +% \end{macrocode} +% Nach dem Paket \pkg{auto-pst-pdf} seine Arbeit verrichtet hat, werden alle +% etwaigen temporär erzeugten Dateien radikal gelöscht. +% \begin{macrocode} + \ifnum\pdf@shellescape=\@ne\relax% + \edef\@tempa{\app@exe{\app@rm "*\app@suffix*"}}% + \@tempa% + \fi% +} +%</package> +% \end{macrocode} +% +% \subsection{ToDo-Liste} +% +% Für Klasse und Paket besteht die Möglichkeit, Änderungsnotizen zu nutzen, +% wofür das Paket \pkg{todonotes} geladen wird. +% \begin{macrocode} +\PassOptionsToPackage{obeyFinal}{todonotes} +% \end{macrocode} +% Für den Druck wird die farbige Ausgabe der ToDo-Notizen deaktiviert. +% \begin{macrocode} +\ifdef{\tudprintflag}{% + \PassOptionsToPackage{color=white}{todonotes}% +}{% + \PassOptionsToPackage{colorinlistoftodos,color=HKS92!10}{todonotes}% +} +\RequirePackage{todonotes}[2012/07/25] +\AtEndPreamble{% + \ifdim\marginparwidth<2cm\relax% + \setlength\marginparwidth{2cm}% + \fi% +} +% \end{macrocode} +% +% \iffalse +%</body> +%<*option> +% \fi +% +% \begin{option}{ToDo} +% \changes{v2.02}{2014/07/10}{neu}^^A +% \changes{v2.05}{2015/10/27}{Nutzung von Positiv- und Negativ-Liste}^^A +% \begin{macro}{\if@tud@todo} +% \changes{v2.02}{2014/07/10}{neu}^^A +% \begin{macro}{\tud@todo@type@pos} +% \changes{v2.05}{2015/10/27}{neu}^^A +% \begin{macro}{\tud@todo@type@neg} +% \changes{v2.05}{2015/10/27}{neu}^^A +% Diese Option ist verantwortlich für den Schalter \cs{if@tud@todo}. Über +% diesen wird gesteuert, ob ToDo-Notizen ausgegeben werden sollen. +% \begin{macrocode} +\newif\if@tud@todo +\newcommand*\tud@todo@type@pos{} +\let\tud@todo@type@pos\relax +\newcommand*\tud@todo@type@neg{} +\let\tud@todo@type@neg\relax +\TUD@key{ToDo}[true]{% + \TUD@set@ifkey{ToDo}{@tud@todo}{#1}% +% \end{macrocode} +% Wird der Option ein boolescher Wert übergeben, sind sowohl die Positiv- als +% auch die Negativ-Liste hinfällig. +% \begin{macrocode} + \ifx\FamilyKeyState\FamilyKeyStateProcessed% + \let\tud@todo@type@pos\relax% + \let\tud@todo@type@neg\relax% + \else% +% \end{macrocode} +% Wird die Option nicht mit einem booleschen Wert verwendet, so kann über diese +% gezielt der Typ einer (nicht) auszugebenden ToDo-Notiz angegeben werden. So +% können bestimmte Typen von Notizen entweder ausschließlich ausgegeben oder +% aber unterdrückt werden, wobei für letztere Variante das Suffix \val{not} +% vor dem eigentlichen Typen verwendet werden muss. +% \begin{macrocode} + \def\@tempa not##1##2##3##4\@nil{% + \ifstr{##1##2##3}{not}{% + \IfArgIsEmpty{##4}{}{% + \listeadd\tud@todo@type@neg{##4}% + \@tud@todotrue% + \FamilyKeyStateProcessed% + }% + }{% + \IfArgIsEmpty{##1}{}{% + \listeadd\tud@todo@type@pos{##1##2##3##4}% + \@tud@todotrue% + \FamilyKeyStateProcessed% + }% + }% + }% + \edef\@tempb{not\trim@spaces{#1}}% + \expandafter\@tempa\@tempb\@empty\@empty\@empty\@nil% + \fi% +} +% \end{macrocode} +% \end{macro}^^A \tud@todo@type@neg +% \end{macro}^^A \tud@todo@type@pos +% \end{macro}^^A \if@tud@todo +% \end{option}^^A ToDo +% +% \iffalse +%</option> +%<*body> +% \fi +% +% \begin{macro}{\ToDo} +% \changes{v2.02}{2014/07/10}{Verwendung von \pkg{todonotes}}^^A +% \changes{v2.03}{2015/01/25}{Ausgabe auf bestimmten Typ beschränkbar}^^A +% \changes{v2.05}{2015/11/02}{Farbkodierung durch optionale Versionsnummer}^^A +% \changes{v2.06}{2018/08/02}{farbige Ausgabe abhängig von Versionsnummer}^^A +% \begin{macro}{\tud@todo@type@use} +% \changes{v2.06}{2018/08/02}{neu}^^A +% \begin{macro}{\ListOfToDo} +% \changes{v2.02}{2014/07/10}{neu}^^A +% Mit dem Befehl \cs{ToDo}\oarg{Option}\marg{ToDo-Notiz}\oarg{Versionsnummer} +% kann bei aktivierter Option \opt{ToDo} eine Notiz mit einer offenen Aufgabe +% erstellt werden. Das erste optionale Argument kann die Kategorisierungstypen +% \val{doc}, \val{imp} und \val{rls} beinhalten, welche für eine spezifische +% farbliche Kodierung sorgen, um die Aufgaben zu kategorisieren. +% \begin{macrocode} +\AfterPackage*{todonotes}{% + \newcommand*\tud@todo@type@use{}% +% \end{macrocode} +% Nun folgt die Definition des eigentlichen Befehls. Dabei wird zu Beginn +% \cs{@currentHref} gesichert und am Ende wiederhergestellt. +% \begin{macrocode} + \NewDocumentCommand\ToDo{s o m !o}{% + \ifbool{@tud@todo}{% + \global\let\tud@currentHref\@currentHref% + \begingroup% +% \end{macrocode} +% In \cs{tud@todo@type@use} werden alle im optionalen Argument angegeben Werte +% gesischer, welche entweder über die Liste \cs{tud@todo@type@pos} explizit +% angefordert oder nicht über die Liste \cs{tud@todo@type@neg} ausgeschlossen +% wurden. +% \begin{macrocode} + \let\tud@todo@type@use\@empty% +% \end{macrocode} +% Das optionale Argument enthält die gewüscnhten Kategorisierungstypen. +% \begin{macrocode} + \IfValueTF{#2}{% + \IfArgIsEmpty{#2}{}{% +% \end{macrocode} +% Die Ausgabe erfolgt entweder für alle ToDo-Notizen oder nur für die per +% Option festgelegten Typen. Dabei wird in einer Schleife geprüft, ob der in +% der aktuellen Notiz angegebene Kategorisierungstyp entweder in der Positv- +% oder aber in der Negativ-Liste enthalten ist. +% \begin{macrocode} + \let\tud@todo@type@use\relax% + \ifx\tud@todo@type@pos\relax% + \def\tud@res@a##1{% + \ifinlist{##1}{\tud@todo@type@use}{}{% + \ifinlist{##1}{\tud@todo@type@neg}{}{% + \listadd\tud@todo@type@use{##1}% + }% + }% + }% + \else% + \def\tud@res@a##1{% + \ifinlist{##1}{\tud@todo@type@use}{}{% + \ifinlist{##1}{\tud@todo@type@pos}{% + \listadd\tud@todo@type@use{##1}% + }{}% + }% + }% + \fi% + \forcsvlist\tud@res@a{#2}% + }% + }{}% +% \end{macrocode} +% Nur wenn mindestens ein aktiver Kategorisierungstyp gefunden wurde oder aber +% gar keine Angabe gemacht wurde, erfolgt die Ausgabe. +% \begin{macrocode} + \ifx\tud@todo@type@use\relax\else% +% \end{macrocode} +% In den temporären Makros werden die Einstellungen für die farbige Ausprägung +% von Randnotiz (\cs{tud@res@a}) und der Textbox im Fließtex(\cs{tud@res@b}) +% sowie das Label der Randnotiz (\cs{tud@res@c}) gespeichert. +% \begin{macrocode} + \let\tud@res@a\@empty% + \let\tud@res@b\@empty% + \let\tud@res@c\@empty% +% \end{macrocode} +% Der Kategorisierungstyp für Releases \val{rls} ist quasi vorkonfiguriert. +% Sind weitere Kategorisierungstypen angegeben, werden diese ignoriert. Der Typ +% für Implemtierung \val{imp} wird vorangig zur Dokumentation \val{doc} +% behandelt. +% \begin{macrocode} + \ifinlist{rls}{\tud@todo@type@use}{% + \def\tud@res@a{color=HKS44!30,}% + \def\tud@res@b{color=HKS44!30,}% + \edef\tud@res@c{v\TUDScriptVersionNumber}% + }{% + \ifinlist{imp}{\tud@todo@type@use}{% + \def\tud@res@a{color=HKS57!50,}% + }{% + \ifinlist{doc}{\tud@todo@type@use}{% + \def\tud@res@a{color=HKS41!30,}% + }{}% + }% +% \end{macrocode} +% Das angestellte optionale Argument erzeugt zusätzlich eine Notiz am Rand, in +% welcher vorzugsweise die angedachte Version eingetragen werden kann. Sollte +% dieser angegeben sein, wird auf eine gültige Versionsnummer geprüft. Dabei +% wird ein möglicherweise vorangestelltes |v| entfernt. +% \begin{macrocode} + \def\tud@res@c{ToDo}% + \IfValueT{#4}{% + \begingroup% +% \end{macrocode} +% Die angegebene Versionsnummer wird geprüft, ob bereits zu einer vergangenen +% Version gehört. In diesem Fall wird die ToDo-Notiz entsprechend als dringlich +% gekennzeichnet. Entspricht die angegebene Versionsnummer einer späteren +% Version, so wird ToDo-Notiz ebenfalls für diese gekennzeichnet. +% \begin{macrocode} + \tud@v@get\tud@res@a{#4}% + \def\tud@res@c##1.##2##3##4\@nil{##1##2##3}% + \edef\tud@res@b{\expandafter\tud@res@c\tud@res@a.000\@nil}% + \ifnumber{\tud@res@b}{% + \edef\tud@res@c{% + \expandafter\tud@res@c\TUDScriptVersionNumber.000\@nil% + }% + \ifnum\tud@res@b>\tud@res@c\relax% + \def\tud@res@b{color=HKS92!30,}% + \else% + \ifnum\tud@res@b<\tud@res@c\relax% + \def\tud@res@b{color=HKS07!50,}% + \else% + \def\tud@res@b{color=HKS41!30,}% + \fi% + \fi% + \def\tud@res@c{v\tud@res@a}% + }{% + \let\tud@res@b\@empty% + \def\tud@res@c{#4}% + }% + \edef\tud@res@c{% + \endgroup% + \def\noexpand\tud@res@b{\tud@res@b}% + \def\noexpand\tud@res@c{\tud@res@c}% + }% + \tud@res@c% + }% + }% +% \end{macrocode} +% Vor der Ausgabe wird ein kleiner vertikaler Abstand eingefügt. +% \begin{macrocode} + \ifhmode\par\fi% + \let\par\relax% + \vskip\medskipamount% + \noindent% +% \end{macrocode} +% Dann erfolgt die Ausgabe der eigentlichen ToDo-Notiz im Textbereich. Die +% Sternversion von \cs{ToDo} unterdrückt dabei die Aufnahme in die ToDo-Liste. +% \begin{macrocode} + \toks@\expandafter{\tud@res@b inline}% + \IfBooleanT{#1}{\addto@hook\toks@{,nolist}}% + \sbox\z@{% + \expandafter\todo\expandafter[\the\toks@]{\trim@spaces{#3}\strut}% + }\usebox\z@% +% \end{macrocode} +% Es folgt die dazugehörige Randnotiz. Damit diese nicht verrutscht, wird +% \cs{marginnote} anstelle von \cs{marginpar} verwendet. Wurde das angestellte +% optionale Argument verwendet, wird dieses für die Randnotiz genutzt. +% Andernfalls erscheint im Rand die Anmerkung \emph{ToDo}. +% \begin{macrocode} + \renewcommand*\marginpar[2][]{% + \marginnote[##1]{##2}[\dimexpr-\ht\z@+1.6ex+1.75pt\relax]% + }% + \toks@\expandafter{\tud@res@a noline,nolist}% + \settowidth\marginparwidth{\tud@res@c}% + \addtolength\marginparwidth{\dimexpr1.6ex+1pt\relax}% + \expandafter\todo\expandafter[\the\toks@]{\tud@res@c\strut}% + \aftergroup\par\aftergroup\noindent% +% \end{macrocode} +% Wurden im ersten optionalen Argument unbekannte Werte gefunden, werden diese +% mit einer Warnung gemeldet. +% \begin{macrocode} + \listremove{\tud@todo@type@use}{rls}% + \listremove{\tud@todo@type@use}{imp}% + \listremove{\tud@todo@type@use}{doc}% + \ifx\tud@todo@type@use\@empty\else% + \begingroup% + \let\tud@res@c\@empty% + \renewcommand*{\do}[1]{% + \appto\tud@res@c{,##1}% + }% + \dolistloop{\tud@todo@type@use}% + \edef\tud@res@c{% + \endgroup% + \edef\noexpand\tud@res@c{\expandafter\@gobble\tud@res@c}% + }% + \tud@res@c% + \ClassWarning{tudscrmanual}{% + Unknown key(s) `\string\ToDo[\tud@res@c]'% + }% + \fi% + \fi% + \endgroup% + \global\let\@currentHref\tud@currentHref% + }{}% + \ignorespaces% + }% +% \end{macrocode} +% Zum Schluss wird der Befehl \cs{ListOfToDo} definiert, der die Liste der noch +% zu erledigenden Punkte ausgibt. +% \begin{macrocode} + \newcommand*\ListOfToDo{\if@tud@todo\clearpage\listoftodos\fi}% +} +% \end{macrocode} +% Sollte das Paket \pkg{todonotes} nicht geladen werden, erfolgt ein Definition +% der beiden notwendigen Befehle als Dummy. +% \begin{macrocode} +\TUD@UnwindPackage{todonotes}{% + \NewDocumentCommand\ToDo{s o m !o}{}% + \newcommand*\ListOfToDo{}% +} +% \end{macrocode} +% \end{macro}^^A \ListOfToDo +% \end{macro}^^A \tud@todo@type@use +% \end{macro}^^A \ToDo +% +% \iffalse +%</body> +%</!doc> +% \fi +% +% \subsection{Verschiedenes für die Dokumentationsklassen und -pakete} +% +% Sowohl für die Klasse \cls{tudscrmanual} als auch \cls{tudscrdoc} werden ein +% paar Befehle zur komfortablen Verwendung im Fließtext definiert. Außerdem +% erfolgen mittels einiger Pakete verschiedene Formateinstellungen. +% +% \subsubsection{Ergänzend geladene Pakete} +% +% Sprachabhängiges Setzen von Anführungszeichen. Das Laden des Paketes darf +% erst nach \pkg{inputenc} oder \pkg{inputenx} erfolgen. +% \begin{macrocode} +%<*body|class&doc> +\RequirePackage{csquotes}[2011/10/22] +%</body|class&doc> +% \end{macrocode} +% +% \iffalse +%<*body> +% \fi +% +% Für den Fließtext werden Pfeile u.\,ä. durch \pkg{textcomp} bereitgestellt. +% \begin{macrocode} +\RequirePackage{textcomp}[2005/09/27] +% \end{macrocode} +% Vergrößerung des Durchschusses. +% \begin{macrocode} +\RequirePackage{setspace}[2011/12/19] +\setstretch{1.1} +% \end{macrocode} +% Verbesserte Zitate. +% \begin{macrocode} +\PassOptionsToPackage{vskip=\smallskipamount}{quoting} +\RequirePackage{quoting}[2014/01/28] +% \end{macrocode} +% Automatisierte Datumsformatierung. +% \begin{macrocode} +\RequirePackage{isodate}[2010/01/03] +% \end{macrocode} +% Verschiedenste Symbole aus dem \LaTeX-Universum. +% \begin{macrocode} +\RequirePackage{hologo}[2012/04/26] +% \end{macrocode} +% +% \iffalse +%<*class> +% \fi +% +% Mit dem Paket \pkg{ragged2e} wird~-- falls benötigt~-- die Silbentrennung im +% Flattersatz aktiviert. +% \begin{macrocode} +\RequirePackage{ragged2e}[2009/05/21] +% \end{macrocode} +% Die Fußnoten werden nicht mit jedem Kapitel zurückgesetzt\dots +% \begin{macrocode} +\@removefromreset{footnote}{chapter} +% \end{macrocode} +% \dots und im Flattersatz ausgegeben. +% \begin{macrocode} +\renewcommand*\raggedfootnote{\tud@RaggedRight}% +% \end{macrocode} +% Das Paket wird für die Erstellung von Tabellen verwendet. +% \begin{macrocode} +\RequirePackage{booktabs}[2005/04/14] +% \end{macrocode} +% Die Formatierung von Gleitobjekten. +% \begin{macrocode} +\RequirePackage{caption}[2015/09/17] +\RequirePackage{floatrow}[2008/08/02] +\DeclareCaptionSubType[alph]{figure} +\DeclareCaptionSubType[alph]{table} +\captionsetup{font=sf,labelfont=bf,labelsep=space} +\captionsetup{singlelinecheck=off,format=hang,justification=raggedright} +\captionsetup[subfloat]{labelformat=brace,list=off} +\KOMAoption{captions}{tableheading,figuresignature} +\floatsetup[table]{style=plaintop} +% \end{macrocode} +% Erstellen von Grafiken. +% \begin{macrocode} +\RequirePackage{tikz}[2013/12/13] +% \end{macrocode} +% Einbinden von ganzseitigen PDF"~Dokumenten als Beispiel im Handbuch. +% \begin{macrocode} +\RequirePackage{pdfpages}[2013/08/25] +% \end{macrocode} +% Typographisch saubere Einheiten. +% \begin{macrocode} +\RequirePackage{units}[1998/08/04] +% \end{macrocode} +% Das Paket \pkg{ellipsis} sorgt für korrekte Auslassungpunkte. +% \begin{macrocode} +\AtEndPreamble{% + \RequirePackage{ellipsis}[2004/9/28]% + \let\ellipsispunctuation\relax% +} +% \end{macrocode} +% +% \iffalse +%</class> +%</body> +%<*body|class&doc> +% \fi +% +% \subsubsection{Gezieltes Ersetzen von Inhalten in Strings} +% +% \begin{macro}{\tud@replace} +% \changes{v2.05}{2015/11/01}{neu}^^A +% Mit diesem Befehl kann in einem gegebenen Makro ein bestimmtes Zeichen durch +% ein anderes ersetzt werden. Dies wird verwendet, um für Indexbefehle oder +% Labels die möglicherweise enthaltenen |@|"~Zeichen zu ersetzen. +% \begin{macrocode} +\newcommand*\tud@replace[3]{% + \begingroup% +% \end{macrocode} +% Zunächst wird \cs{@tempa} als ein durch \cs{@nil} abgegrenztes Makro mit +% zwei Argumenten definiert, wobei diese durch das im zweiten Argument gegebene +% \meta{Zeichen} voneinander abgegrenzt werden. Mit diese beiden Argumente wird +% das Makro \cs{@tempb} aufgerufen. +% \begin{macrocode} + \toks@{\def\@tempa##1}% + \eaddto@hook\toks@{\detokenize{#2}}% + \addto@hook\toks@{##2\@nil{\@tempb{##1}{##2}}}% +% \end{macrocode} +% Der Inhalt von \cs{toks@} ist +% \cs{def}\cs{@tempa\#1\meta{Zeichen}\#2}\cs{@nil\{\cs{@tempb\{\#1\}\{\#2\}}\}} +% und definiert \cs{@tempa}. +% \begin{macrocode} + \the\toks@% +% \end{macrocode} +% Nun wird \cs{@tempb} definiert. Dieses Makro fügt dem Zielmakro das erste +% Argumente gefolgt von \meta{Ersatzzeichen} hinzu. Mit dem zweiten Argument +% wird anschließend \cs{@tempa\#\#2}\cs{@nil} so lange rekursiv aufgerufen, bis +% es wirklich leer ist, wodurch das zweite Argument \meta{Zeichen} sukzessive +% durch das dritte Argument \meta{Ersatzzeichen} ersetzt wird. +% \begin{macrocode} + \def\@tempb##1##2{% + \IfArgIsEmpty{##2}{% + \appto#1{##1}% + \let\@tempc\relax% + }{% + \appto#1{##1#3}% + \def\@tempc{\@tempa##2\@nil}% + }% + \@tempc% + }% +% \end{macrocode} +% Nachdem die beiden notwendigen Makros definiert wurden, erfolgt jetzt die +% eigentliche Ersetzung. Dafür wird der Inhalt des Zielmakros als Argument für +% \cs{@tempa} verwendet. Diesem wird das zu ersetzende Zeichen gefolgt von +% \cs{@nil} hinzugefügt, um das Argument abschließend zu begrenzen. +% \begin{macrocode} + \toks@{\@tempa}% + \edef\@tempc{\expandafter\detokenize\expandafter{#1}}% + \eaddto@hook\toks@{\@tempc}% + \eaddto@hook\toks@{\detokenize{#2}\@nil}% +% \end{macrocode} +% Der Inhalt von \cs{toks@} hat die Form \cs{@tempa\#1\meta{Zeichen}}\cs{@nil}, +% wobei der Inhalt von \meta{\#1} expandiert wird. +% \begin{macrocode} + \def#1{}% + \the\toks@% + \edef\tud@reserved{% + \noexpand\endgroup% + \def\noexpand#1{#1}% + }% + \tud@reserved% +} +% \end{macrocode} +% \end{macro}^^A \tud@replace +% +% \iffalse +%</body|class&doc> +%<*body> +% \fi +% +% +% \subsubsection{Zusätzliche Markup-Befehle} +% +% \begin{macro}{\Attention} +% \changes{v2.02}{2014/08/16}{neu}^^A +% \begin{macro}{\Forum} +% \begin{macro}{\CTAN} +% \changes{v2.05}{2015/11/22}{neu}^^A +% \begin{macro}{\GitHubRepo} +% \changes{v2.02}{2014/08/16}{neu}^^A +% \begin{macro}{\Download} +% \changes{v2.05g}{2016/11/08}{neu}^^A +% \begin{macro}{\notudscrartcl} +% \begin{macro}{\scrguide} +% \changes{v2.02}{2014/09/04}{neu}^^A +% \changes{v2.05}{2015/07/23}{Hyperlinktext über optionales Argument}^^A +% Für die Anwenderdokumentation werden weitere Auszeichnungsbefehle definiert. +% \begin{macrocode} +\newcommand*\Attention[2][\z@]{% + \marginnote{% + \setlength\fboxsep{0.25em}% + \fbox{Achtung!}% + }[#1]% + \emph{\trim@spaces{#2}}% +} +\NewDocumentCommand\Forum{!s !t'}{% + \IfBooleanTF{#1}{\toks@{\href}}{\toks@{\hrfn}}% + \IfBooleanT{#2}{\toks@{\url}}% + \addto@hook\toks@{{http://latex.wcms-file3.tu-dresden.de/phpBB3/}}% + \IfBooleanF{#2}{\addto@hook\toks@{{TUD-\LaTeX-Forum}}}% + \the\toks@\xspace% +} +\NewDocumentCommand\CTAN{!s !o !g}{% + \IfBooleanTF{#1}{\toks@{\href}}{\toks@{\hrfn}}% + \addto@hook\toks@{{http://www.ctan.org/\IfValueT{#2}{#2}}}% + \addto@hook\toks@{% + {\tud@english{Comprehensive TeX Archive Network (CTAN\IfValueT{#3}{~#3})}}% + }% + \the\toks@\xspace% +} +%<*class> +\NewDocumentCommand\GitHubRepo{!s !t' !O{releases}}{% + \IfBooleanTF{#1}{\toks@{\href}}{\toks@{\hrfn}}% + \IfBooleanT{#2}{\toks@{\url}}% + \addto@hook\toks@{{https://github.com/tud-cd/tudscr/#3}}% + \IfBooleanF{#2}{% + \addto@hook\toks@{{\tud@english{GitHub-Repository~\Distribution*{tudscr}}}}% + }% + \the\toks@\xspace% +} +\newcommand*\Download[1]{% + https://github.com/tud-cd/tudscr/releases/download/#1% +} +\newcommand*\notudscrartcl{% + F\"ur die Klassen \Class{tudscrartcl} sowie \Class{tudscrposter} ist diese + Option nicht verf\"ugbar.% +} +%</class> +\NewDocumentCommand\scrguide{!s !O{\KOMAScript-Handbuch}}{% + \IfBooleanTF{#1}{\toks@{\href}}{\toks@{\hrfn}}% + \addto@hook\toks@{% + {http://mirrors.ctan.org/macros/latex/contrib/koma-script/doc/scrguide.pdf}% + }% + \addto@hook\toks@{{#2}}% + \the\toks@\xspace% +} +% \end{macrocode} +% \end{macro}^^A \scrguide +% \end{macro}^^A \notudscrartcl +% \end{macro}^^A \Download +% \end{macro}^^A \GitHubRepo +% \end{macro}^^A \CTAN +% \end{macro}^^A \Forum +% \end{macro}^^A \Attention +% +% \iffalse +%</body> +%<*body|class&doc> +% \fi +% +% \begin{macro}{\CD} +% \begin{macro}{\CDs} +% \begin{macro}{\TUD} +% \begin{macro}{\TnUD} +% \begin{macro}{\TUDCD} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\TUDCDs} +% \changes{v2.05}{2015/11/01}{neu}^^A +% \begin{macro}{\DDC} +% Diese Befehle stellen regelmäßig in der Quelltextdokumentatuion und im +% Handbuch genutzte Textbausteine bereit. Dazu wird der Befehl \cs{xspace} aus +% dem \pkg{xspace}-Paket genutzt. +% \begin{macrocode} +\newcommand*\CD{\tud@english{Corporate Design}\xspace} +\newcommand*\CDs{\tud@english{Corporate Designs}\xspace} +\newcommand*\TUD{Technische Universit\"at Dresden\xspace} +\newcommand*\TnUD{Technischen Universit\"at Dresden\xspace} +\newcommand*\TUDCD{\CD der \TnUD} +\newcommand*\TUDCDs{\CDs der \TnUD} +\newrobustcmd*\DDC{% + \mbox{% + D\kern.05em R\kern.05em E\kern.05em S\kern.05em % + D\kern.05em E\kern.05em N\kern.1em-\kern.1em concept% + }\xspace% +} +\AfterPackage*{hyperref}{% + \pdfstringdefDisableCommands{% + \def\DDC{DRESDEN-concept}% + \def\TUDScript{TUD-Script}% + \def\KOMAScript{KOMA-Script}% + }% +} +% \end{macrocode} +% \end{macro}^^A \DDC +% \end{macro}^^A \TUDCDs +% \end{macro}^^A \TUDCD +% \end{macro}^^A \TnUD +% \end{macro}^^A \TUD +% \end{macro}^^A \CDs +% \end{macro}^^A \CD +% \begin{macro}{\OpenSans} +% \changes{v2.06}{2018/07/02}{neu}^^A +% \begin{macro}{\tud@cdfont@texteb} +% \changes{v2.06}{2018/08/31}{neu}^^A +% \begin{macro}{\Univers} +% \begin{macro}{\DIN} +% Für die Nennung der Schriften spezielle Markos bereitgestellt. +% \begin{macrocode} +\DeclareTextFontCommand\tud@cdfont@texteb{% + \fontfamily{\tud@cdfont@fam}\fontseries{\tud@cdfont@ebf}\selectfont% +} +\newrobustcmd*\OpenSans{% + \texorpdfstring{\tud@cdfont@texteb{Open~Sans}}{Open Sans}\xspace% +} +\newrobustcmd*\Univers{\texorpdfstring{\textcdbi{Univers}}{Univers}\xspace} +\newrobustcmd*\DIN{\texorpdfstring{\textcdxi{DIN~Bold}}{DIN Bold}\xspace} +% \end{macrocode} +% \end{macro}^^A \DIN +% \end{macro}^^A \Univers +% \end{macro}^^A \tud@cdfont@texteb +% \end{macro}^^A \OpenSans +% \begin{macro}{\@pnumwidth} +% \begin{macro}{\@tocrmarg} +% Für das Inhaltsverzeichnis werden die beiden Längen angepasst. +% \begin{macrocode} +\renewcommand*\@pnumwidth{2.1em}% +\renewcommand*\@tocrmarg{3.1em}% +% \end{macrocode} +% \end{macro}^^A \@tocrmarg +% \end{macro}^^A \@pnumwidth +% +% \iffalse +%</body|class&doc> +%<*body> +% \fi +% +% \begin{macro}{\textsbn} +% \changes{v2.02}{2014/08/16}{neu}^^A +% \begin{macro}{\sbnfont} +% \changes{v2.02}{2014/08/16}{neu}^^A +% \begin{macro}{\textsbs} +% \changes{v2.02}{2014/08/16}{neu}^^A +% \begin{macro}{\sbsfont} +% \changes{v2.02}{2014/08/16}{neu}^^A +% Für die Anwenderdokumentation werden weitere Auszeichnungsbefehle definiert. +% \begin{macrocode} +\newcommand*\textsbn{} +\newrobustcmd*\sbnfont{\sffamily\bfseries\upshape} +\DeclareTextFontCommand\textsbn{\sbnfont} +\newcommand*\textsbs{} +\newrobustcmd*\sbsfont{\sffamily\bfseries\slshape} +\DeclareTextFontCommand\textsbs{\sbsfont} +% \end{macrocode} +% \end{macro}^^A \sbsfont +% \end{macro}^^A \textsbs +% \end{macro}^^A \sbnfont +% \end{macro}^^A \textsbn +% +% \iffalse +%</body> +% \fi +% +% \Finale +% +\endinput |