diff options
Diffstat (limited to 'Master/texmf-dist/source/latex/tudscr/tudscr-base.dtx')
-rw-r--r-- | Master/texmf-dist/source/latex/tudscr/tudscr-base.dtx | 1378 |
1 files changed, 968 insertions, 410 deletions
diff --git a/Master/texmf-dist/source/latex/tudscr/tudscr-base.dtx b/Master/texmf-dist/source/latex/tudscr/tudscr-base.dtx index 7a47fa64ccf..863a42ecd0b 100644 --- a/Master/texmf-dist/source/latex/tudscr/tudscr-base.dtx +++ b/Master/texmf-dist/source/latex/tudscr/tudscr-base.dtx @@ -1,10 +1,10 @@ -% \CheckSum{842} % \iffalse meta-comment +%/GitFileInfo=tudscr-base.dtx % % TUD-Script -- Corporate Design of Technische Universität Dresden % ---------------------------------------------------------------------------- % -% Copyright (C) Falk Hanisch <hanisch.latex@outlook.com>, 2012-2021 +% Copyright (C) Falk Hanisch <hanisch.latex@outlook.com>, 2012-2022 % % ---------------------------------------------------------------------------- % @@ -23,44 +23,19 @@ % % \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-base.dtx -%<*dtx> -% \fi -% -\ifx\ProvidesFile\undefined\def\ProvidesFile#1[#2]{}\fi -\ProvidesFile{tudscr-base.dtx}[2020/09/29 v2.06j TUD-Script\space% -% -% \iffalse -%</dtx> -%<package&base>\ProvidesPackage{tudscrbase}[% -%<*package&base> -%!TUD@Version -%</package&base> -%<package&base> package -%<*dtx|package&base> -% \fi - (basics for the bundle)% -] -% \iffalse -%</dtx|package&base> +% \iffalse ins:batch + dtx:driver +%<*ins> +\ifx\documentclass\undefined + \input docstrip.tex + \ifToplevel{\batchinput{tudscr.ins}} +\else + \let\endbatchfile\relax +\fi +\endbatchfile +%</ins> %<*dtx> +\ProvidesFile{tudscr-base.dtx}[2022/08/09] +\RequirePackage{tudscr-gitinfo} \documentclass[english,ngerman,xindy]{tudscrdoc} \iftutex \usepackage{fontspec} @@ -70,18 +45,11 @@ \fi \usepackage{babel} \usepackage{tudscrfonts} -\KOMAoptions{parskip=half-} -\usepackage{bookmark} \usepackage[babel]{microtype} -\CodelineIndex -\RecordChanges -\GetFileInfo{tudscr-base.dtx} -\title{\file{\filename}} -\author{Falk Hanisch\qquad\expandafter\mailto\expandafter{\tudscrmail}} -\date{\fileversion\nobreakspace(\filedate)} - +\GitHubBase{\TUDScriptRepository} \begin{document} + \author{Falk Hanisch\TUDScriptContactTitle} \maketitle \tableofcontents \DocInput{\filename} @@ -93,21 +61,32 @@ % % \changes{v2.02}{2014/06/23}{Paket \pkg{titlepage} nicht weiter unterstützt}^^A % +% +% % \section{Das Paket \pkg{tudscrbase} -- Basisdefinitionen für \TUDScript} % % Für die Erstellung der \TUDScript-Klassen werden die dafür benötigten Pakete % eingebunden und Steuerungsbefehle definiert. Die Klassen sowie einige Pakete % benötigen das Paket und laden dieses auch. % -% \ToDo{% -% Schnittstelle äquivalent zu \cs{KOMA@kav@\dots}? Dann hierfür -% \pkg{etoolbox}-Listen und \cs{listadd} sowie \cs{listremove} nutzen -% }[v2.??] -% \ToDo{% +% \begin{macrocode} +%<*package&base> +\ProvidesPackage{tudscrbase}[% +%!TUD@Version + package (basics for the bundle)% +] +%</package&base> +% \end{macrocode} +% +% \ToDo{ +% Schnittstelle äquivalent zu \cs{KOMA@kav@...}? Dann hierfür +% \pkg{etoolbox}-Listen und \cs{listadd} sowie \cs{listremove} nutzen +% }[v2.08] +% \ToDo{ % Teile im Quelltext suchen, die nur einmalig durchlaufen werden müssen % (bspw. notwendige Pakete und Schriften) und über aux-Eintrag abkürzen?! -% siehe \cs{TUD@CheckPackage}% -% }[v2.??] +% siehe \cs{TUD@CheckPackage} +% }[v2.07] %^^A\BeforeClosingMainAux{% %^^A \if@tud@xxx\if@filesw% %^^A \immediate\write\@mainaux{% @@ -117,62 +96,248 @@ %^^A} % % -% \StopEventually{\PrintIndex\PrintChanges\PrintToDos} % % \begin{macrocode} %<*load> -\RequirePackage{tudscrbase}[\TUD@Version] +\RequirePackage{tudscrbase}[% +%!TUD@Version +] %</load> % \end{macrocode} % -% \subsection{Notwendige Pakete für \TUDScript} -% % \iffalse %<*package&base> % \fi % +% \subsection{Notwendige Kompatibilitätseinstellung für \KOMAScript} +% +% Die installierte Version und die gewählte Kompatibilitätseinstellung von +% \KOMAScript{} wird gerpüft. +% \begin{macrocode} +\AtBeginDocument{% + \ifcsundef{scr@v@first}{}{% +% \end{macrocode} +% Es wird gerpüft, ob die mindestens benötigte \KOMAScript-Version +% (v\csuse{TUD@KOMAVersionNumber}) verfügbar ist. Sollte dies nicht der Fall +% sein, wird ein Fehler erzeugt. +% \begin{macrocode} + \ifcsundef{scr@v@\TUD@KOMAVersionNumber}{% + \PackageError{tudscrbase}{% + KOMA-Script v\TUD@KOMAVersionNumber\space is required% + }{% + \TUD@Version\space must be used at least with\MessageBreak% + \TUD@KOMAVersion, but only\MessageBreak% + \KOMAScriptVersion\space was found.% + }% + }{% +% \end{macrocode} +% Ist die mindestens nötige Version von \KOMAScript{} installiert, wird +% geprüft, ob die Kompatibilitätseinstellung akzeptabel ist. +% \begin{macrocode} + \expandafter\ifnum\scr@v@is@lt{3.12}\relax% + \PackageError{tudscrbase}{% + KOMA-Script compatibility level too low% + }{% + \TUD@Version\space must be used at least with\MessageBreak% + `version=3.12' KOMA-Script compatibility option.% + }% + \fi% + }% + }% +} +% \end{macrocode} +% +% \subsection{Notwendige Pakete für \TUDScript} +% +% \changes{v2.06f}{2020/01/14}{Anpassungen für \pkg{scrbase} \val{v3.28}}^^A % Das Paket \pkg{scrbase} wird zur Optionsdefinition benötigt, \pkg{scrlfile} % für verschiedene Hooks vor sowie nach Klassen und Paketen. -% \ToDo{Provisorium entfernen}[v2.07] -% \begin{macrocode} -\providecommand*{\ifstr}{\Ifstr} -\providecommand*{\ifstrstart}{\Ifstrstart} -\providecommand*{\ifisskip}{\Ifisskip} -\providecommand*{\ifdimen}{\Ifdimen} -\providecommand*{\ifisdimen}{\Ifisdimen} -\providecommand*{\ifisdimension}{\Ifisdimension} -\providecommand*{\ifnumber}{\Ifnumber} -\RequirePackage{scrbase}[2020/09/21] -\RequirePackage{iftex}[2019/11/07] +% \begin{macrocode} +\RequirePackage{scrbase}[% +%!TUD@KOMAVersion +] % \end{macrocode} % Die folgenden Pakete werden für die Manipulation bereits definierter -% Makros sowie zur erweiterten Auswertung boolescher Ausdrücke benötigt. +% Makros, zur erweiterten Auswertung boolescher Ausdrücke und allgemein zur +% Ablaufsteuerung benötigt. % \begin{macrocode} -\RequirePackage{etoolbox}[2011/01/03] -\RequirePackage{xpatch}[2012/10/02] -\RequirePackage{letltxmacro}[2016/05/16] -\RequirePackage{etexcmds}[2011/02/16] +\RequirePackage{iftex} +\RequirePackage{etoolbox} +\RequirePackage{xpatch} +\RequirePackage{letltxmacro} % \end{macrocode} % Das Paket \pkg{kvsetkeys} erweitert \pkg{keyval} um die Möglichkeit, das % Verhalten bei der Angabe eines nicht definierten Schlüssels festzulegen. -% \ToDo{sollte eigentlich auch mit KOMA-Option \val{@else@} gehen}[v2.07] +% \ToDo{sollte auch mit KOMA-Option \val{@else@} gehen, besser raus}[v2.07] % \begin{macrocode} -\RequirePackage{kvsetkeys}[2012/04/25] +\RequirePackage{kvsetkeys} % \end{macrocode} % Mit dem Paket \pkg{trimspaces} können eventuell vorhandene Leerzeichen aus % einem Argument entfernt. Dies wird beispielsweise beim Einlesen von Feldern % oder bei der expliziten Auswahl einer Schrift des \CD sgenutzt. % \begin{macrocode} -\RequirePackage{trimspaces}[2009/09/17] +\RequirePackage{trimspaces} +% \end{macrocode} +% Für \pkg{hyperref} werden \cs{TUDScript} und \cs{KOMAScript} deaktiviert. +% \begin{macrocode} +\AfterPackage*{hyperref}{% + \pdfstringdefDisableCommands{% + \def\TUDScript{TUD-Script}% + \def\KOMAScript{KOMA-Script}% + }% +} % \end{macrocode} % % \subsection{Grundlegende Befehle für \TUDScript} +% \subsubsection{Erweiterte Definition von \TeX-Primitiven} +% +% Mit \LaTeX{} lassen sich einige Primitiven definieren, ohne zu Prüfen, ob +% ggf. bereits eine Definition vorhanden ist. Dies wird hiermit umgangen. +% \begin{macro}{\tud@newif} +% \changes{v2.06o}{2022/07/27}{neu}^^A +% \begin{macro}{\tud@newcount} +% \changes{v2.06o}{2022/07/27}{neu}^^A +% \begin{macro}{\tud@newtoks} +% \changes{v2.06o}{2022/07/27}{neu}^^A +% \begin{macro}{\tud@newread} +% \changes{v2.06o}{2022/07/27}{neu}^^A +% \begin{macro}{\tud@newwrite} +% \changes{v2.06o}{2022/07/27}{neu}^^A +% \begin{macrocode} +\newcommand*\tud@newif[1]{\@ifdefinable#1{\newif#1}} +\newcommand*\tud@newcount[1]{\@ifdefinable#1{\newcount#1}} +\newcommand*\tud@newtoks[1]{\@ifdefinable#1{\newtoks#1}} +\newcommand*\tud@newread[1]{\@ifdefinable#1{\newread#1}} +\newcommand*\tud@newwrite[1]{\@ifdefinable#1{\newwrite#1}} +% \end{macrocode} +% \end{macro}^^A \tud@newwrite +% \end{macro}^^A \tud@newread +% \end{macro}^^A \tud@newtoks +% \end{macro}^^A \tud@newcount +% \end{macro}^^A \tud@newif +% +% \subsubsection{Definition von Längen-Registern} +% +% \begin{macro}{\tud@newglue} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% \begin{macro}{\tud@newdim} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% \begin{macro}{\tud@setglue} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% \begin{macro}{\tud@setdim} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% \begin{macro}{\tud@addtoglue} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% \begin{macro}{\tud@addtodim} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% Der \LaTeX"~Kernel stellt lediglich \cs{newlength} zur Verfügung, um bereits +% bestehende Makros nicht zu überschreiben. Soll jedoch ein \cs{dimen}-Register +% definiert werden, gibt es keinen entsprechenden Befehl. Auch die Zuweisung +% von Längenwerte kann mit \cs{setlength} nicht sauber erfolgen, da nicht +% geprüft wird, ob die Zuweisung an ein \cs{skip}"~ oder \cs{dimen}-Register +% erfolgt. Deshalb werden hier für diese Aufgabe interne Befehle definiert. +% Siehe dazu auch \GitHubRepo(latex3/latex2e)<227>. +% \begin{macrocode} +\newcommand*\tud@newglue[1]{\@ifdefinable#1{\newskip#1}} +\newcommand*\tud@newdim[1]{\@ifdefinable#1{\newdimen#1}} +\newrobustcmd*\tud@setglue[2]{% + \ifdefdimen{#1}{% + \PackageWarning{tudscrbase}{% + You tried to assign dimen \string#1\MessageBreak% + so \string\tud@setdim\space is used% + }% + \tud@setdim{#1}{#2}% + }{% + \setlength#1{\glueexpr#2\relax}% + }% +} +\newrobustcmd*\tud@setdim[2]{% + \begingroup% + \@tud@res@swafalse% + \setlength\@tempskipa{\glueexpr#2\relax}% + \ifdim\gluestretch\@tempskipa=\z@\relax\else% + \@tud@res@swatrue% + \fi% + \ifdim\glueshrink\glueexpr\@tempskipa\relax=\z@\relax\else% + \@tud@res@swatrue% + \fi% + \if@tud@res@swa% + \PackageWarning{tudscrbase}{% + You tried to use \string\tud@setdim\string#1\MessageBreak% + with glue \detokenize{#2} (\the\@tempskipa)\MessageBreak% + but only the base value is used% + }% + \fi% + \endgroup% + \setlength#1{\dimexpr\glueexpr#2\relax\relax}% +} +\newrobustcmd*\tud@addtoglue[2]{% + \tud@setglue#1{\glueexpr#1+#2\relax}% +} +\newrobustcmd*\tud@addtodim[2]{% + \tud@setdim#1{\glueexpr#1+#2\relax}% +} +% \end{macrocode} +% \end{macro}^^A \tud@addtodim +% \end{macro}^^A \tud@addtoglue +% \end{macro}^^A \tud@setdim +% \end{macro}^^A \tud@setglue +% \end{macro}^^A \tud@newdim +% \end{macro}^^A \tud@newglue +% \begin{macro}{\tud@res@glue} +% \changes{v2.06}{2019/06/21}{neu}^^A +% Und gleich noch eine temporäre Länge mit dazu. +% \begin{macrocode} +\tud@newglue\tud@res@glue +% \end{macrocode} +% \end{macro}^^A \tud@res@glue +% \begin{macro}{\tud@if@lengthregister} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% Prüft, ob der übergebene Befehl ein \cs{skip}"~ oder \cs{dimen}-Register ist. +% \begin{macrocode} +\newcommand*\tud@if@lengthregister[1]{% + \begingroup% + \@tud@res@swafalse% + \ifdeflength{#1}{\@tud@res@swatrue}{}% + \ifdefdimen{#1}{\@tud@res@swatrue}{}% + \if@tud@res@swa% + \aftergroup\@firstoftwo% + \else% + \aftergroup\@secondoftwo% + \fi% + \endgroup% +} +% \end{macrocode} +% \end{macro}^^A \tud@if@lengthregister +% \begin{macro}{\tud@length@setabsolute} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% Um Schlüssel für Längen definieren zu können, die zwingend positiv sind, kann +% dieses Makro genutzt werden. Übergeben werden muss entweder eine Länge oder +% ein Makro, welches einen Längenausdruck enthält. +% \begin{macrocode} +\newcommand*\tud@length@setabsolute[1]{% + \tud@if@lengthregister{#1}{% + \ifdim#1<\z@% + \setlength#1{-\glueexpr#1\relax}% + \fi% + }{% + \protected@edef#1{% + \noexpand\ifdim\noexpand\glueexpr\expandonce#1\relax<\z@-\noexpand\fi% + \noexpand\glueexpr\expandonce#1\relax% + }% + }% +} +% \end{macrocode} +% \end{macro}^^A \tud@length@setabsolute +% % \subsubsection{Temporäre Makros zur internen Verwendung durch \TUDScript} % % Hier werden Makros definiert, die allein für die interne temporäre Nutzung % gedacht sind. -% \ToDo{Sämtliche \cs{@temp\dots}-Makros auf \cs{tud@res@\dots} ändern}[v2.??] -% \ToDo{\cs{tud@reserved} in \cs{tud@res@?}, Achtung bei Dopplungen!}[v2.??] +% \ToDo{sämtliche \cs{@temp...}-Makros auf \cs{tud@res@...} ändern}[v2.07] +% \ToDo{\cs{tud@reserved} in \cs{tud@res@...}, Achtung bei Dopplungen!}[v2.07] +% \ToDo{Schlüssel sollten weiterhin \cs{@temp...}-Makros verwenden}[v2.07] +% \ToDo{Makros mit \val{@num} in count ändern}[v2.07] % \begin{macro}{\tud@reserved} % \changes{v2.05}{2015/10/27}{neu}^^A % \begin{macro}{\tud@res@a} @@ -181,104 +346,229 @@ % \changes{v2.06}{2018/07/12}{neu}^^A % \begin{macro}{\tud@res@c} % \changes{v2.06}{2018/07/12}{neu}^^A +% \begin{macro}{\tud@res@d} +% \changes{v2.06}{2018/07/12}{neu}^^A % \begin{macro}{\if@tud@res@swa} % \changes{v2.06}{2018/07/12}{neu}^^A % \begin{macro}{\tud@res@cnt} % \changes{v2.06}{2019/06/13}{neu}^^A -% \begin{macro}{\tud@res@read} -% \changes{v2.06}{2019/06/21}{neu}^^A % Makros zur temporären Verwendung. % \begin{macrocode} \newcommand*\tud@reserved{} \newcommand*\tud@res@a{} \newcommand*\tud@res@b{} \newcommand*\tud@res@c{} -\newif\if@tud@res@swa -\newcount\tud@res@cnt -\newread\tud@res@read +\newcommand*\tud@res@d{} +\tud@newif\if@tud@res@swa +\tud@newcount\tud@res@cnt % \end{macrocode} -% \end{macro}^^A \tud@res@read % \end{macro}^^A \tud@res@cnt % \end{macro}^^A \if@tud@res@swa +% \end{macro}^^A \tud@res@d % \end{macro}^^A \tud@res@c % \end{macro}^^A \tud@res@b % \end{macro}^^A \tud@res@a % \end{macro}^^A \tud@reserved % \begin{macro}{\tud@toks@} % \changes{v2.05}{2015/11/01}{neu}^^A -% \begin{macro}{\eaddto@hook} +% \begin{macro}{\addto@hook@expandafter} % \changes{v2.05}{2015/11/01}{neu}^^A % Es wird ein token-Regsiter reserviert, welches im weiteren Verlauf an allen -% möglichen Punkten verwendet wird. Mit \cs{eaddto@hook} wird~-- in Ergänzung -% zu \cs{addto@hook}~-- ein Makro zum Anfügen des expandierten Arguments an ein -% token-Register bereitgestellt. +% möglichen Punkten verwendet wird. Mit \cs{addto@hook@expandafter} wird~-- in +% Ergänzung zu \cs{addto@hook} aus dem \LaTeX"~Kernel~-- ein Makro zum Anfügen +% des expandierten Arguments an ein token-Register bereitgestellt. % \begin{macrocode} -\newtoks\tud@toks@ -\newcommand*\eaddto@hook[2]{% +\tud@newtoks\tud@toks@ +\newcommand*\addto@hook@expandafter[2]{% \expandafter\addto@hook\expandafter#1\expandafter{#2}% } % \end{macrocode} -% \end{macro}^^A \eaddto@hook +% \end{macro}^^A \addto@hook@expandafter % \end{macro}^^A \tud@toks@ % -% \subsubsection{Robuster Test auf leeres Argument} -% -% \begin{macro}{\ifxblank} -% Hiermit kann ein Argument geprüft werden, ob dieses blank ist (leer oder -% Leerzeichen). In seiner Syntax ist er identisch zu \cs{ifblank}, allerdings -% expandiert er im Gegensatz zu diesem das gegebene Argument. -% \begin{macrocode} -\newcommand*\ifxblank{\ifstr{}} +% \subsubsection{Verzweigung für Präambel und Dokument} +% +% \begin{macro}{\tud@if@preamble} +% \changes{v2.05o}{2022/07/25}{als Ersatz für \cs{if@atdocument}}^^A +% Mit \KOMAScript~v3.37 wurde das Aktivieren des Schalters \cs{if@atdocument} +% aufgrund des stark veränderten und damit leider nur bedingt deterministischen +% \hrfn{https://sourceforge.net/p/koma-script/tickets/23/}{Hook-Managements} +% des Kernels auf |begindocument/before| verschoben. Dieser Befehl wird als +% Gegenstück definiert und führt in Abhängigkeit von |begindocument/after| +% Quelltext verzweigt aus. +% \begin{macrocode} +\newcommand*\tud@if@preamble{} +\let\tud@if@preamble\@firstoftwo +\AfterEndPreamble{\let\tud@if@preamble\@secondoftwo} +% \end{macrocode} +% \end{macro}^^A \tud@if@preamble +% +% \subsubsection{Strings} +% \minisec{Expandierte Tests} +% +% \begin{macro}{\tud@if@strequal} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% \begin{macro}{\tud@if@strstart} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% \begin{macro}{\tud@if@strempty} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% \begin{macro}{\tud@if@strblank} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% Hiermit wird geprüft, ob ein String gleich, leer oder blank (Leerzeichen) +% ist, wobei die gegebene Argumente expandiert werden. In ihrer Syntax sind +% sie identisch zu den aus aus \pkg{etoolbox} stammenden und unterlagerten +% Befehlen \cs{ifstrequal}, \cs{ifstrempty} und \cs{ifblank}. Der Befehl +% \cs{tud@if@strstart} nutzt \cs{Ifstrstart} von \KOMAScript. +% \begin{macrocode} +\newcommand*\tud@if@strequal[2]{% + \begingroup% + \protected@edef\tud@res@a{% + \endgroup% + \noexpand\ifstrequal{#1}{#2}% + }% + \tud@res@a% +} +\newcommand*\tud@if@strstart[2]{% + \begingroup% + \protected@edef\tud@res@a{% + \endgroup% + \noexpand\Ifstrstart{\noexpand\detokenize{#1}}{\noexpand\detokenize{#2}}% + }% + \tud@res@a% +} +\newcommand*\tud@if@strempty{\tud@if@strequal{}} +\newcommand*\tud@if@strblank[1]{% + \begingroup% + \protected@edef\tud@res@a{% + \endgroup% + \noexpand\ifblank{#1}% + }% + \tud@res@a% +} % \end{macrocode} -% \end{macro}^^A \ifxblank +% \end{macro}^^A \tud@if@strblank +% \end{macro}^^A \tud@if@strempty +% \end{macro}^^A \tud@if@strstart +% \end{macro}^^A \tud@if@strequal % -% \subsubsection{Test auf booleschen Ausdruck in Form eines Strings} +% \minisec{Test auf booleschen Ausdruck in Form eines Strings} % -% \begin{macro}{\ifstrbool} +% \begin{macro}{\tud@if@strbool} % \changes{v2.03}{2015/01/09}{neu}^^A % Dieser Befehl dient zum Testen, ob ein gegebener String als boolescher % Ausdruck interpretiert werden kann. Ist der String als \enquote{wahr} % interpretierbar, wird das zweite Argument ausgeführt. Kann der String als % \enquote{falsch} angesehen werden, dementsprechen das dritte. Ist der String % kein logischer Wert, kommt das letzte Argument zum Tragen. Die Syntax lautet: -% -% \cs{ifstrbool}\marg{Argument}\marg{Wahr}\marg{Falsch}\marg{Andernfalls} -% \begin{macrocode} -\newcommand*\ifstrbool[4]{% - \ifstr{#1}{true}{#2}{% - \ifstr{#1}{on}{#2}{% - \ifstr{#1}{yes}{#2}{% - \ifstr{#1}{false}{#3}{% - \ifstr{#1}{no}{#3}{% - \ifstr{#1}{off}{#3}{% - #4% - }% - }% - }% +% \newline +% \cs{tud@if@strbool}\marg{Argument}\marg{Wahr}\marg{Falsch}\marg{Andernfalls} +% \begin{macrocode} +\newcommand*\tud@if@strbool[4]{% + \TUD@set@ifkey{strbool}{@tempswa}{#1}% + \ifx\FamilyKeyState\FamilyKeyStateProcessed% + \if@tempswa#2\else#3\fi% + \else% + #4 + \fi% +} +% \end{macrocode} +% \end{macro}^^A \tud@if@strbool +% +% \minisec{Erzwungene Kleinschreibung von Strings} +% +% \begin{macro}{\tud@strlowercase} +% Dieses Makro expandiert das zweite Argument, setzt es in Minuskeln und +% speichert das Ergebnis in den im ersten Argument angegebenen Befehl. Dies +% wird zum Beispiel benötigt, um bestimmte Werte bei Schlüssel-Wert-Paaren, +% Schlüsselwörtern in einigen Feldern oder auch Einheiten bei Längenangaben +% sicher erkennen zu können. Die Syntax lautet: +% \newline +% \cs{tud@strlowercase}\marg{Zielmakro}\marg{String} benutzt. +% \begin{macrocode} +\newcommand*\tud@strlowercase[2]{% + \protected@edef#1{% + \lowercase{\def\noexpand#1{#2}}% + }#1% +} +% \end{macrocode} +% \end{macro}^^A \tud@strlowercase +% +% \minisec{Ausgabe einer Länge als Strings} +% +% \begin{macro}{\tud@strlength} +% \changes{v2.06o}{2022/07/28}{neu}^^A +% Die direkte Verwendung von \cs{the} auf ein \cs{skip}-Register hat zur Folge, +% dass die Einheit \val{pt} mit die Charactercodes \val{12} zurückgegeben +% werden, was bei der Weiterverarbeitung unter Umständen Probleme bereitet. +% Dieses Makro löst das Problem. +% \begin{macrocode} +\newcommand*\tud@strlength[2]{% + \begingroup% + \def\tud@res@c{\glueexpr#2\relax}% + \edef\tud@res@a{\strip@pt\dimexpr\tud@res@c\relax pt}% + \edef\tud@res@b{\strip@pt\dimexpr\gluestretch\tud@res@c\relax}% + \ifdim\tud@res@b\p@=\z@\relax\else% + \eappto\tud@res@a{% + \space\@plus\space\tud@res@b% + \ifcase\gluestretchorder\tud@res@c pt\or fil\or fill\or filll\fi% + }% + \fi% + \edef\tud@res@b{\strip@pt\dimexpr\glueshrink\tud@res@c\relax}% + \ifdim\tud@res@b\p@=\z@\relax\else% + \eappto\tud@res@a{% + \space\@minus\space\tud@res@b% + \ifcase\glueshrinkorder\tud@res@c pt\or fil\or fill\or filll\fi% }% + \fi% + \edef\tud@res@a{% + \endgroup% + \unexpanded{\def#1}{\tud@res@a}% }% - }% + \tud@res@a% } % \end{macrocode} -% \end{macro}^^A \ifstrbool +% \end{macro}^^A \tud@strlength +% +% \minisec{Entfernen aller Leerzeichen in Strings} +% +% \begin{macro}{\tud@remove@spaces@within} +% Hiermit können in einem gegebenen String \emph{alle} Leerzeichen enthaltenen +% entfernt werden. Dies wird verwendet, um für \cs{TUD@set@gluekey} sowie +% \cs{TUD@set@dimkey} eine Warnung auszugeben, falls das übergebene Argument +% fehlerhaft formatiert ist, wobei Unterschiede bei Leerzeichen ignoriert +% werden sollen. +% \begin{macrocode} +\newcommand*\tud@remove@spaces@within[1]{% + \begingroup% + \protected@edef\tud@res@a{\noexpand\zap@space#1\space\noexpand\@empty}% + \protected@edef\tud@res@a{% + \endgroup% + \unexpanded{\def#1}{\tud@res@a}% + }% + \tud@res@a% +} +% \end{macrocode} +% \end{macro}^^A \tud@remove@spaces@within % % \subsubsection{Test auf eine verwendbare Sprache} % % \begin{macro}{\iflanguageloaded} % \changes{v2.05}{2015/11/23}{neu}^^A % Hiermit kann getestet werden, ob das Argument als Sprache nutzbar ist. -% \ToDo{ist Befehl noch sinnvoll? use polyglossia \cs{xpg@[b]loaded}?}[v2.07] -% \ToDo{für polyglossia auch mit \cs{ifbabellanguageloaded} testen?}[v2.07] -% \ToDo{besser nur als internen Befehl definieren \cs{tud@if@...}?!}[v2.07] % \begin{macrocode} -\newcommand*\iflanguageloaded[1]{% - \PackageWarning{tudscrbase}{% - Whether package `babel' nor package `polyglossia' has been loaded% +\AtEndPreamble{% + \providecommand*\iflanguageloaded[1]{% + \PackageWarning{tudscrbase}{% + `\string\iflanguageloaded' is not defined. Loading\MessageBreak% + either package `babel' or package `polyglossia'\MessageBreak% + is recommended% + }% + \def\iflanguageloaded##1{\expandafter\@secondoftwo}% + \iflanguageloaded{#1}% }% - \expandafter\@secondoftwo% } \AfterPackage*{babel}{% - \renewcommand*\iflanguageloaded[1]{% + \providecommand*\iflanguageloaded[1]{% \@expandtwoargs\in@{,#1,}{,\bbl@loaded,}% \ifin@% \expandafter\@firstoftwo% @@ -287,13 +577,12 @@ \fi% }% } -\BeforePackage{polyglossia}{\undef\iflanguageloaded} % \end{macrocode} % \end{macro}^^A \iflanguageloaded % % \subsubsection{Expansion geschützter Makros} % -% Im \LaTeX-Kernel wird der Befehl \cs{@expandtwoargs} definiert, welcher zwei +% Im \LaTeX"~Kernel wird der Befehl \cs{@expandtwoargs} definiert, welcher zwei % Argumente in ein angegebenes Makro vollständig expandiert. Dabei erfolgt die % Expansion der beiden Argumente aufgrund der standardmäßigen Verwendung von % \cs{edef} allerdings vollständig und ohne die Beachtung von \cs{protect}. @@ -310,7 +599,7 @@ % % \subsubsection{Division für rationale Zahlen} % -% Mit \LaTeXe{} kann~-- ohne die Verwendung zusätzlicher Pakete~-- nicht ohne +% Mit \LaTeX{} kann~-- ohne die Verwendung zusätzlicher Pakete~-- nicht ohne % Weiteres eine Division durchgeführt werden, die als Ergenis eine rationale % Zahl liefert. Dem wird hier Abhilfe geleistet. % \begin{macro}{\tud@divide} @@ -335,29 +624,29 @@ % \begin{macrocode} \ifdim\@tempdima>\@tempdimb\relax% \@whiledim\@tempdimb>1pt\relax\do{% - \setlength\@tempdima{.1\@tempdima}% - \setlength\@tempdimb{.1\@tempdimb}% + \setlength\@tempdima{\dimexpr\@tempdima/10\relax}% + \setlength\@tempdimb{\dimexpr\@tempdimb/10\relax}% }% \setlength\@tempdimc{\@tempdima}% \else% \@whiledim\@tempdima>1pt\relax\do{% - \setlength\@tempdima{.1\@tempdima}% - \setlength\@tempdimb{.1\@tempdimb}% + \setlength\@tempdima{\dimexpr\@tempdima/10\relax}% + \setlength\@tempdimb{\dimexpr\@tempdimb/10\relax}% }% \setlength\@tempdimc{\@tempdimb}% \fi% \@tempcnta=1\relax% - \@whiledim\dimexpr\@tempcnta\@tempdimc\relax<.01\maxdimen\do{% + \@whiledim% + \dimexpr\@tempcnta\@tempdimc\relax<\dimexpr\maxdimen/100\relax% + \do{% \multiply\@tempcnta by 10\relax% }% % \end{macrocode} % Mit dem im temporären Zählerregister \cs{@tempcnta} gespeicherten Faktor % wird der Dividend erweitert und der berechnete Quotient wieder gekürzt. % \begin{macrocode} - \setlength\@tempdimc{% - \dimexpr(\@tempcnta\@tempdima / \@tempdimb * \p@)\relax% - }% - \setlength\@tempdimc{\dimexpr \@tempdimc/\@tempcnta\relax}% + \setlength\@tempdimc{\dimexpr(\@tempcnta\@tempdima/\@tempdimb*\p@)\relax}% + \setlength\@tempdimc{\dimexpr\@tempdimc/\@tempcnta\relax}% % \end{macrocode} % Das Ergebnis wird in das angegebene Makro expandiert. % \begin{macrocode} @@ -367,24 +656,6 @@ % \end{macrocode} % \end{macro}^^A \tud@divide % -% \subsubsection{Erzwungene Kleinschreibung von Strings} -% -% Um angegebene Werte bei Schlüssel-Wert-Paaren oder Schlüsselwörter in -% bestimmten Feldern mit Sicherheit erkennen zu können, werden diese zwingend -% in Kleinbuchstaben geschieben. -% \begin{macro}{\tud@lowerstring} -% Das Makro wird mit \cs{tud@lowerstring}\marg{Zielmakro}\marg{String} benutzt. -% \ToDo{geht das eleganter als mit \cs{expandafter}?}[v2.07] -% \begin{macrocode} -\newcommand*\tud@lowerstring[2]{% - \protected@edef#1{#2}% - \lowercase\expandafter{% - \expandafter\def\expandafter #1\expandafter{#1}% - }% -} -% \end{macrocode} -% \end{macro}^^A \tud@lowerstring -% % \subsubsection{Test auf vorhandene Dateien von Schriftdefinitionen} % % \begin{macro}{\tud@if@fdfileexists} @@ -401,14 +672,14 @@ % Varianten getestet. Zunächst die Standardvariante in Kleinschreibung\dots % \begin{macrocode} \@tud@res@swatrue% - \tud@lowerstring\tud@res@a{#1#2.fd}% + \tud@strlowercase\tud@res@a{#1#2.fd}% \IfFileExists{\tud@res@a}{\@tud@res@swafalse}{}% % \end{macrocode} % \dots gefolgt von der Variante mit Kleinschreibung der Kodierung und dem % Namen der Schrift wie angegeben\dots % \begin{macrocode} \if@tud@res@swa% - \tud@lowerstring\tud@res@a{#1}% + \tud@strlowercase\tud@res@a{#1}% \edef\tud@res@a{\tud@res@a#2.fd}% \IfFileExists{\tud@res@a}{\@tud@res@swafalse}{}% \fi% @@ -437,14 +708,11 @@ % \begin{macro}{\tud@cs@letltx} % \changes{v2.06}{2019/06/13}{\cs{LetLtxMacro} zum Sichern originärer Makros}^^A % \begin{macro}{\tud@cs@store} -% \changes{v2.06}{2018/07/15}{% -% mit \cs{DeclareRobustCommand} definierte Befehle unterstüzt% -% }^^A +% \changes{v2.06}{2018/07/15}{mit \cs{DeclareRobustCommand} definierte Befehle +% werden unterstüzt}^^A % \begin{macro}{\tud@cs@restore} -% \changes{v2.06}{2018/07/15}{% -% stellt originäre Makros auch wieder her, wenn diese mit \cs{undef} -% zwischendurch \emph{undefiniert} gesetzt wurden% -% }^^A +% \changes{v2.06}{2018/07/15}{stellt originäre Makros auch wieder her, wenn +% diese mit \cs{undef} zwischendurch \emph{undefiniert} gesetzt wurden}^^A % \begin{macro}{\tud@cs@reset} % \begin{macro}{\tud@cs@update} % \changes{v2.04}{2015/03/03}{neu}^^A @@ -458,6 +726,7 @@ % % Der Befehl \cs{tud@cs@letltx} nutzt intern \cs{LetLtxMacro} aus dem Paket % \pkg{letltxmacro}, um auch robust definierte Befehle korrekt zu sichern. +% \ToDo{Kernel stellt mittlerweiele \cs{NewCommandCopy} bereit}[v2.07] % \begin{macrocode} \newcommand*\tud@cs@letltx[2]{% \expandafter\expandafter\expandafter\LetLtxMacro% @@ -465,21 +734,22 @@ } % \end{macrocode} % Mit dem Aufruf \cs{tud@cs@store}\marg{Befehlsname} wird der im Argument -% angegebene Befehl in einem neuem Makro \cs{@@tud@\meta{Befehlsname}} +% angegebene Befehl in einem neuem Makro |\@@tud@|\meta{Befehlsname} % gespeichert. Dieser kann danach beliebig angepasst werden. Soll der Befehl zu % einem späteren Zeitpunkt auf den Orginalzustand zurücksetzen, kann hierfür % jederzeit der Befehl \cs{tud@cs@reset}\marg{Befehlsname} verwendet werden. % Durch das Makro \cs{tud@cs@restore}\marg{Befehlsname} wird das mit -% \cs{tud@cs@store} erstellte Hilfsmakro zusätzlich noch gelöscht. Der +% \cs{tud@cs@store} erstellte Hilfsmakro zusätzlich noch gelöscht. Der % ursprüngliche Befehl kann als solcher mit \cs{tud@cs@use}\marg{Befehlsname} % weiterhin genutzt werden. Ein zuvor bereits gesicherter Befehl kann mit % \cs{tud@cs@update}\marg{Befehlsname} auf die momentane Definition % aktualisiert werden. % \begin{macrocode} \newrobustcmd*\tud@cs@store[1]{% - \tud@cs@check{#1}% - \ifcsdef{@@tud@#1}{}{% - \tud@cs@letltx{@@tud@#1}{#1}% + \tud@cs@check{#1}{% + \ifcsdef{@@tud@#1}{}{% + \tud@cs@letltx{@@tud@#1}{#1}% + }% }% } \newrobustcmd*\tud@cs@restore[1]{% @@ -497,30 +767,34 @@ % \end{macrocode} % Die eigentliche Wiederherstellung. % \begin{macrocode} - \tud@cs@check{#1}% - \ifcsdef{@@tud@#1}{% - \tud@cs@letltx{#1}{@@tud@#1}% - \csundef{@@tud@#1}% - }{}% + \tud@cs@check{#1}{% + \ifcsdef{@@tud@#1}{% + \tud@cs@letltx{#1}{@@tud@#1}% + \csundef{@@tud@#1}% + }{}% + }% } \newrobustcmd*\tud@cs@reset[1]{% - \tud@cs@check{#1}% - \ifcsdef{@@tud@#1}{% - \tud@cs@letltx{#1}{@@tud@#1}% - }{}% + \tud@cs@check{#1}{% + \ifcsdef{@@tud@#1}{% + \tud@cs@letltx{#1}{@@tud@#1}% + }{}% + }% } \newrobustcmd*\tud@cs@update[1]{% - \tud@cs@check{#1}% - \ifcsdef{@@tud@#1}{% - \tud@cs@letltx{@@tud@#1}{#1}% - }{}% + \tud@cs@check{#1}{% + \ifcsdef{@@tud@#1}{% + \tud@cs@letltx{@@tud@#1}{#1}% + }{}% + }% } \newrobustcmd*\tud@cs@use[1]{% - \tud@cs@check{#1}% - \ifcsdef{@@tud@#1}{% - \csuse{@@tud@#1}% - }{% - \csuse{#1}% + \tud@cs@check{#1}{% + \ifcsdef{@@tud@#1}{% + \csuse{@@tud@#1}% + }{% + \csuse{#1}% + }% }% } % \end{macrocode} @@ -529,14 +803,24 @@ % Fall sein, wird ein Fehler ausgegeben. % \begin{macrocode} \newrobustcmd*\tud@cs@check[1]{% - \ifcsdef{#1}{}{% - \PackageError{tudscrbase}{% - `\@backslashchar#1' is not defined}{% - The command `\@backslashchar#1' was never defined. \MessageBreak% - Please contact the TUD-Script maintainer\MessageBreak% - via \tudscrmail. A bugfix is urgently required.% - }% - }% + \begingroup% + \ifcsdef{#1}{\@tud@res@swatrue}{\@tud@res@swafalse}% + \if@tud@res@swa% + \ifcscounter{#1}{\@tud@res@swafalse}{}% + \ifcslength{#1}{\@tud@res@swafalse}{}% + \ifcsdimen{#1}{\@tud@res@swafalse}{}% + \fi% + \if@tud@res@swa% + \aftergroup\@firstofone% + \else% + \PackageError{tudscrbase}{`\@backslashchar#1' is not a defined macro}{% + The macro `\@backslashchar#1' was never defined. \MessageBreak% + Please contact the TUD-Script maintainer\MessageBreak% + via \TUDScriptContact. A bugfix is urgently required.% + }% + \aftergroup\@gobble% + \fi% + \endgroup% } % \end{macrocode} % \end{macro}^^A \tud@cs@check @@ -546,78 +830,74 @@ % \end{macro}^^A \tud@cs@restore % \end{macro}^^A \tud@cs@store % \end{macro}^^A \tud@cs@letltx -% \begin{macro}{\tud@skip@store} +% \begin{macro}{\tud@cslength@store} % \changes{v2.04}{2015/03/02}{neu}^^A -% \changes{v2.05}{2016/07/13}{Verwendung von \cs{tud@skip@check}}^^A -% \begin{macro}{\tud@skip@restore} +% \changes{v2.05}{2016/07/13}{Verwendung von \cs{tud@cslength@check}}^^A +% \begin{macro}{\tud@cslength@restore} % \changes{v2.04}{2015/03/02}{neu}^^A -% \changes{v2.05}{2016/07/13}{Verwendung von \cs{tud@skip@check}}^^A -% \begin{macro}{\tud@skip@reset} +% \changes{v2.05}{2016/07/13}{Verwendung von \cs{tud@cslength@check}}^^A +% \begin{macro}{\tud@cslength@reset} % \changes{v2.05}{2016/07/13}{neu}^^A -% \begin{macro}{\tud@skip@set} -% \changes{v2.04}{2015/05/05}{neu}^^A -% \changes{v2.05}{2016/07/13}{Verwendung von \cs{tud@skip@check}}^^A -% \begin{macro}{\tud@skip@check} +% \begin{macro}{\tud@cslength@check} % \changes{v2.05}{2016/07/13}{neu}^^A % Hiermit können~-- äquivalent zum Sichern und Wiederherstellen von Befehlen~-- % Längenregister abgespeichert werden. % \begin{macrocode} -\newcommand*\tud@skip@store[1]{% - \tud@skip@check{#1}{% - \ifcsdef{@@tud@skip@#1}{}{% - \csedef{@@tud@skip@#1}{\expandafter\the\csname #1\endcsname}% - }% - }% -} -\newcommand*\tud@skip@restore[1]{% - \tud@skip@check{#1}{% - \ifcsdef{@@tud@skip@#1}{% - \csname #1\endcsname=\csname @@tud@skip@#1\endcsname% - \csundef{@@tud@skip@#1}% +\newcommand*\tud@cslength@store[1]{% + \tud@cslength@check{#1}{% + \ifcsundef{@@tud@length@#1}{% + \csedef{@@tud@length@#1}{\expandafter\the\csname #1\endcsname}% }{}% }% } -\newcommand*\tud@skip@reset[1]{% - \tud@skip@check{#1}{% - \ifcsdef{@@tud@skip@#1}{% - \csname#1\endcsname=\csname @@tud@skip@#1\endcsname% - }{}% +\newcommand*\tud@cslength@restore[1]{% + \tud@cslength@check{#1}{% + \ifcsundef{@@tud@length@#1}{}{% + \expandafter\setlength\csname #1\endcsname{% + \csname @@tud@length@#1\endcsname% + }% + \csundef{@@tud@length@#1}% + }% }% } -\newcommand*\tud@skip@set[2]{% - \tud@skip@check{#1}{% - \expandafter\setlength\csname #1\endcsname{#2}% +\newcommand*\tud@cslength@reset[1]{% + \tud@cslength@check{#1}{% + \ifcsundef{@@tud@length@#1}{}{% + \expandafter\setlength\csname #1\endcsname{% + \csname @@tud@length@#1\endcsname% + }% + }% }% } -\newcommand*\tud@skip@check[1]{% - \begingroup% - \@tempswafalse% - \expandafter\ifisskip\expandafter{\csname#1\endcsname}{\@tempswatrue}{}% - \expandafter\ifisdimen\expandafter{\csname#1\endcsname}{\@tempswatrue}{}% - \if@tempswa% - \aftergroup\@firstofone% - \else% - \aftergroup\@gobble% - \fi% - \endgroup% +\newcommand*\tud@cslength@check[1]{% + \expandafter\tud@if@lengthregister\expandafter{\csname #1\endcsname}{% + \expandafter\@firstofone% + }{% + \PackageError{tudscrbase}{`\@backslashchar#1' is not a defined length}{% + The length `\@backslashchar#1' was never defined. \MessageBreak% + Please contact the TUD-Script maintainer\MessageBreak% + via \TUDScriptContact. A bugfix is urgently required.% + }% + \expandafter\@gobble% + }% } % \end{macrocode} -% \end{macro}^^A \tud@skip@check -% \end{macro}^^A \tud@skip@set -% \end{macro}^^A \tud@skip@reset -% \end{macro}^^A \tud@skip@restore -% \end{macro}^^A \tud@skip@store +% \end{macro}^^A \tud@cslength@check +% \end{macro}^^A \tud@cslength@reset +% \end{macro}^^A \tud@cslength@restore +% \end{macro}^^A \tud@cslength@store % \begin{macro}{\tud@patch@wrn} % \TUDScript verwendet die Möglichkeiten von \pkg{etoolbox} und \pkg{xpatch}, % um mit den Makros (\cs{[x]apptocmd}, \cs{[x]pretocmd}, \cs{[x]patchcmd}) % bereits definierte Befehle anzupassen. Falls dies nicht gelingt, wird eine % Warnung ausgegeben, die hier definiert wird. +% \ToDo{generelle Schnittstelle schaffen und failure hier behandeln}[v2.07] % \begin{macrocode} \newcommand*\tud@patch@wrn[1]{% \PackageWarning{tudscrbase}{% It wasn't possible to patch `\@backslashchar#1'\MessageBreak% Please contact the TUD-Script maintainer\MessageBreak% - via \tudscrmail. Without a bugfix an\MessageBreak% + via \TUDScriptContact. Without a bugfix an\MessageBreak% erroneous output may occur% }% } @@ -637,8 +917,12 @@ % Zuerst ein paar Makros zur einfacheren Verwendung. % \begin{macrocode} \DefineFamily{TUD} -\newcommand*\TUDProcessOptions{\FamilyProcessOptions{TUD}} -\newcommand*\TUDExecuteOptions{\FamilyExecuteOptions{TUD}} +\newcommand*\TUDProcessOptions[1][.\@currname.\@currext]{% + \FamilyProcessOptions[{#1}]{TUD}% +} +\newcommand*\TUDExecuteOptions[1][.\@currname.\@currext]{% + \FamilyExecuteOptions[{#1}]{TUD}% +} \newcommand*\TUDoptions{\FamilyOptions{TUD}} \newcommand*\TUDoption{\FamilyOption{TUD}} % \end{macrocode} @@ -663,7 +947,7 @@ % aber in bestimmten Fällen eine Option in Abhängigkeit von einer anderen % unterschiedliche Standardwerte annehmen soll, wird dafür eine Möglichkeit % geschaffen. Hierfür wird für jede Option ein korrelierende Schalter -% \cs{if@tud@key@\meta{Schlüssel}@set} definiert. Dieser wird auf \val{true} +% |\if@tud@key@|\meta{Schlüssel}|@set| definiert. Dieser wird auf \val{true} % gesetzt, sobald der Schlüssel explizit gesetzt wurde, womit ein Standardwert % einer Klassenoption überschrieben werden kann. Das Setzen der Standardwerte % erfolgt intern mit dem Befehl \cs{TUD@key@preset}. @@ -671,7 +955,7 @@ \newcommand*\TUD@key[2][.\@currname.\@currext]{% % \end{macrocode} % Basierend auf dem Namen des Schalters wird die notwendige, boolesche Variable -% erzeugt (\cs{if@tud@key@\meta{Schlüssel}@set}), welche im Falle des direkten +% erzeugt (|\if@tud@key@|\meta{Schlüssel}|@set|), welche im Falle des direkten % Aufrufs des Schlüssels, ein Überschreiben mit einem Standardwert verhindert. % \begin{macrocode} \providebool{@tud@key@#2@set}% @@ -699,7 +983,7 @@ }% } % \end{macrocode} -% Es kann intern über \cs{if@tud@key@\meta{Schlüssel}@set} geprüft werden, ob +% Es kann intern über |\if@tud@key@|\meta{Schlüssel}|@set| geprüft werden, ob % einem Schlüssel ein explizites Wert zugewiesen wurde. Sollte dies nicht der % Fall sein, kann dieser hiermit intern beliebig angepasst werden. Da es durch % das Setzen der Option mit \cs{TUDoption} zu einer Sperrung kommt, muss diese @@ -716,34 +1000,41 @@ % \end{macro}^^A \TUD@key@@define % \end{macro}^^A \TUD@key@define % \end{macro}^^A \TUD@key +% +% Die folgenden Befehle dienen zum Verarbeiten der Optionen, wobei prinzipiell +% auch eine freie Definition mit anschließender Abarbeitung ohne diese möglich +% ist. +% % \begin{macro}{\TUD@set@ifkey} % \changes{v2.06}{2018/08/01}{forcierte Kleinschreibung Schlüsselwerte}^^A +% Hiermit wird der Option ein einfacher Schalterwert zugewiesen. +% \begin{macrocode} +\newcommand*\TUD@set@ifkey[3]{% + \begingroup% + \tud@strlowercase\tud@res@a{#3}% + \edef\tud@res@a{% + \endgroup% + \unexpanded{\FamilySetBool{TUD}{#1}{#2}}{\tud@res@a}% + }% + \tud@res@a% +} +% \end{macrocode} +% \end{macro}^^A \TUD@set@ifkey % \begin{macro}{\TUD@set@numkey} % \changes{v2.02}{2014/11/05}{neu}^^A % \changes{v2.06}{2018/08/01}{forcierte Kleinschreibung Schlüsselwerte}^^A % \begin{macro}{\TUD@bool@numkey} % \changes{v2.03}{2015/01/09}{neu}^^A -% \begin{macro}{\TUD@set@dimenkey} -% \changes{v2.05}{2016/06/15}{neu}^^A -% \changes{v2.06}{2018/08/01}{forcierte Kleinschreibung Schlüsselwerte}^^A -% \begin{macro}{\TUD@unknown@keyval} -% Dies sind die Befehle zum Setzen der Optionen. Diese können entweder als -% Schalter (\cs{TUD@set@ifkey}) oder aber mit mehreren möglichen Werten -% (\cs{TUD@set@numkey}) definiert werden. Prinzipiell ist auch eine freie -% Definition mit anschließender Abarbeitung ohne die zuvor genannten Befehle -% möglich. +% Hiermit werden für eine Option mehrere mögliche Werte definiert. % \begin{macrocode} -\newcommand*\TUD@set@ifkey[3]{% - \tud@lowerstring\tud@res@a{#3}% - \edef\tud@res@b{% - \etex@unexpanded{\FamilySetBool{TUD}{#1}{#2}}{\tud@res@a}% - }\tud@res@b% -} \newcommand*\TUD@set@numkey[4]{% - \tud@lowerstring\tud@res@a{#4}% - \edef\tud@res@b{% - \etex@unexpanded{\FamilySetNumerical{TUD}{#1}{#2}{#3}}{\tud@res@a}% - }\tud@res@b% + \begingroup% + \tud@strlowercase\tud@res@a{#4}% + \edef\tud@res@a{% + \endgroup% + \unexpanded{\FamilySetNumerical{TUD}{#1}{#2}{#3}}{\tud@res@a}% + }% + \tud@res@a% } % \end{macrocode} % Um Dopplungen im Code zu vermeiden, werden für die numerische Schlüssel die @@ -753,16 +1044,322 @@ {false}{0},{off}{0},{no}{0},{true}{1},{on}{1},{yes}{1}% } % \end{macrocode} -% Mit \cs{TUD@set@dimenkey} wird der übergebene Längenwert im spezifiezierten -% Makro gespeichert. +% \end{macro}^^A \TUD@bool@numkey +% \end{macro}^^A \TUD@set@numkey +% \begin{macro}{\TUD@set@gluekey} +% \changes{v2.06o}{2022/08/01}{neu}^^A +% \begin{macro}{\tud@normalize@gluekey} +% \changes{v2.06o}{2022/08/01}{neu}^^A +% \begin{macro}{\tud@normalize@@gluekey} +% \changes{v2.06o}{2022/08/01}{neu}^^A +% \begin{macro}{\tud@validate@gluekey} +% \changes{v2.06o}{2022/08/01}{neu}^^A +% Mit \cs{TUD@set@gluekey} und \cs{TUD@set@dimkey} wird der übergebene Wert +% entweder als Skip (Länge mit Kleister) oder Dimension (Länge ohne Kleister) +% im spezifizierten Makro gespeichert, wobei auf eine gültige Eingabe geprüft +% wird. +% +% Wurde ein Argument übergeben, dass in einen String expandiert, ist einiger +% Aufwand notwendig, da das zugrunde liegende \cs{FamilySetLength} einen Fehler +% wirft, wenn eine Längenangabe mit falscher Einheit übergeben wird. Das +% optionale Argument gibt die gewünschte Längeneinheit an, falls diese im +% Argument nicht spezifiert wurde. +% \begin{macrocode} +\newcommand*\TUD@set@gluekey[4][pt]{% + \begingroup% + \tud@strlowercase\tud@res@a{#4}% +% \end{macrocode} +% Es wird geprüft, ob das Argument zu einem String expandiert. Ist dies der +% Fall, wird die vermeintliche Längenangabe mit \cs{tud@normalize@gluekey} +% normalisiert, wobei das Resultat in das Makro im ersten Argument des Befehls +% zurückgeschrieben wird. Sollte das Normalisieren nicht gelingen, wird ein +% leerer Wert zurückgegeben. +% \begin{macrocode} + \edef\tud@res@b{\detokenize\expandafter{\tud@res@a}}% + \edef\tud@res@c{\detokenize\expandafter{\@backslashchar}}% + \@expandtwoargs\in@{\tud@res@c}{\tud@res@b}% + \ifin@\else% + \tud@normalize@gluekey\tud@res@a{#1}% + \fi% +% \end{macrocode} +% Konnte eine Längenangabe interpretiert werden, wird für ein falsch +% formatiertes Argument mit \cs{tud@validate@gluekey} ggf. eine Warnung +% ausgegeben und anschließend der gültige Wert gesetzt. +% \begin{macrocode} + \protected@edef\tud@res@a{% + \endgroup% + \ifx\tud@res@a\@empty% + \noexpand\FamilyKeyStateUnknownValue% + \else% + \unexpanded{\tud@validate@gluekey{#2}}{\tud@res@a}{#4}% + \unexpanded{\FamilySetUseLengthMacro{TUD}{#2}{#3}}{\tud@res@a}% + \fi% + }% + \tud@res@a% +} +% \end{macrocode} +% Das Makro \cs{tud@normalize@gluekey} erhält im ersten Argument den zu +% interpretierenden String und im zweiten die ggf. zu setzende Einheit. Dieser +% String wird in den Basiswert und möglichen Kleister aufgetrennt, wobei +% hierbei auch eine vertauschte und eigentlich fehlerhafte Angabe von Kleister +% in der Form |... minus ... plus ...| verarbeitet wird. +% \begin{macrocode} +\newcommand*\tud@normalize@gluekey[2]{% + \begingroup% + \edef\tud@res@c{#1}% + \def\tud@res@a##1plus##2plus##3\@nil{% + \let\tud@res@a\@empty% + \tud@res@b##1minusminus\@nil% + \tud@res@b##2minusminus\@nil% + }% +% \end{macrocode} +% Die vier Token \marg{Grundwert}\marg{negativ}\marg{positiv}\marg{negativ} +% werden in \cs{tud@res@a} geschrieben, wobei der zweite Token mit negativem +% Kleister gesetzt ist, falls dieser \emph{vor} dem positiven angegeben wurde. % \begin{macrocode} -\newcommand*\TUD@set@dimenkey[3]{% - \tud@lowerstring\tud@res@a{#3}% - \edef\tud@res@b{% - \etex@unexpanded{\FamilySetUseLengthMacro{TUD}{#1}{#2}}{\tud@res@a}% - }\tud@res@b% + \def\tud@res@b##1minus##2minus##3\@nil{% + \eappto\tud@res@a{{\trim@spaces{##1}}{\trim@spaces{##2}}}% + }% + \expandafter\tud@res@a\tud@res@c plusplus\@nil% +% \end{macrocode} +% Hier wird dementsprechend \cs{tud@res@a} auf drei Token reduziert und so +% definiert, dass auf den Grundwert erst der positive und danach der negative +% Kleister folgt. +% \begin{macrocode} + \def\tud@res@b##1##2##3##4{% + \IfArgIsEmpty{##2}{% + \def\tud@res@a{{##1}{##3}{##4}}% + }{% + \def\tud@res@a{{##1}{##3}{##2}}% + }% + }% + \expandafter\tud@res@b\tud@res@a% +% \end{macrocode} +% Jeder der drei Token wird nun mit \cs{tud@normalize@@gluekey} geprüft, ob +% es sich tatsächlich um eine Dimensionsangabe oder zumindest einen Zahlenwert +% handelt. Für letzteren Fall wird die übergebene Einheit angehangen. Kann ein +% Token nicht als Dimensionsangabe interpretiert werden~-- das übergebene Makro +% wird zu \cs{relax} gesetzt~-- wird der Prozess abgebrochen. +% \begin{macrocode} + \edef\tud@res@b{% + \unexpanded{\@tfor\tud@res@b:=}\tud@res@a% + }% + \let\tud@res@c\@empty% + \@tud@res@swatrue% + \tud@res@b\do{% + \tud@normalize@@gluekey\tud@res@a{\tud@res@b}{#2}% + \ifx\tud@res@a\relax% + \@tud@res@swafalse% + \@break@tfor% + \else% + \eappto\tud@res@c{{\tud@res@a}}% + \fi% + }% +% \end{macrocode} +% Nach dem Durchlauf enthält \cs{tud@res@c} alle drei zuvor extrahierten Token, +% die ggf. um eine Einheit ergänzt wurden, falls diese gegeben waren. Der erste +% Token erhält folgend eine Sonderbehandlung. Wenn dieser leer ist, wird er auf +% alle Fälle gesetzt, da es sonst zu Problemen bei der Wertzuweisung an ein +% Längenregister gibt. +% \begin{macrocode} + \let\tud@res@a\@empty% + \if@tud@res@swa% + \def\tud@res@b##1##2##3{% + \IfArgIsEmpty{##1}{\def\tud@res@b{0#2}}{\def\tud@res@b{##1}}% + \Ifdimen{\tud@res@b}{% + \edef\tud@res@a{% + \tud@res@b% + \IfArgIsEmpty{##2}{}{\space\@plus\space##2}% + \IfArgIsEmpty{##3}{}{\space\@minus\space##3}% + }% + }{}% + }% + \expandafter\tud@res@b\tud@res@c% + \fi% + \edef\tud@res@c{% + \endgroup% + \unexpanded{\def#1}{\tud@res@a}% + }% + \tud@res@c% } % \end{macrocode} +% Diese Makro behandelt die einzelnen extrahierten Token. Dabei müssen zuerst +% die Vorzeichen beachtet werden, welches erst in \cs{tud@res@b} gesichert und +% anschließend von \cs{tud@res@a} entfernt wird. +% \begin{macrocode} +\newcommand*\tud@normalize@@gluekey[3]{% + \begingroup% + \edef\tud@res@a{#2}% + \@tud@res@swafalse% + \expandafter\if\expandafter\@car\tud@res@a\relax\@nil+\@tud@res@swatrue\fi% + \expandafter\if\expandafter\@car\tud@res@a\relax\@nil-\@tud@res@swatrue\fi% + \if@tud@res@swa% + \protected@edef\tud@res@b{\expandafter\@car\tud@res@a\relax\@nil}% + \protected@edef\tud@res@a{\expandafter\@gobble\tud@res@a}% + \else% + \let\tud@res@b\@empty% + \fi% +% \end{macrocode} +% Danach wird mit \cs{Ifdimen} geprüft, ob die Angabe tatsächlich eine Länge +% ist. Hier kommt zum Tragen, das \cs{Ifdimen} auch wahr ist, wenn lediglich +% eine gültige Einheit ohne Maßzahl (\cs{Ifdimen}|{pt}|) angegeben wird. +% Für Werte ohne Dimensionsangabe wird gegebenenfalls einfach das optionale +% Argument als intendierte angenommen. Sollte es sich bei dem Argument nicht um +% einen String sondern um eine \TeX"~Primitive oder ein geschütztes Makro +% handeln, wird kein \val{true}-Zweig durchlaufen. +% \begin{macrocode} + \@tud@res@swatrue% + \Ifdimen{\tud@res@a}{}{% + \Ifdimen{\tud@res@a#3}{% + \appto\tud@res@a{#3}% + }{% + \@tud@res@swafalse% + }% + }% +% \end{macrocode} +% Wertangaben ohne Betrag werden ignoriert. +% \begin{macrocode} + \if@tud@res@swa% + \Ifisdimension{\tud@res@a}{}{% + \let\tud@res@a\@empty% + \let\tud@res@b\@empty% + }% + \else% +% \end{macrocode} +% Sollte keine gültige Dimension angegeben worden sein, wird nun geprüft, ob es +% sich um eine dehnbare Länge handelt. Diese \emph{muss} mit einer Maßzahl +% genutzt werden. Fehlt diese, wird \val{1} angenommen. Außerdem ist zu +% beachten, dass es insgesamt drei Abstufungen der dehnbaren Ausdrücke +% existieren. +% \begin{macrocode} + \def\tud@res@c##1fil##2fil##3\@nil{% + \IfArgIsEmpty{##1}{\def\tud@res@a{1}}{\def\tud@res@a{##1}}% + \Ifdimen{\tud@res@a pt}{\@tud@res@swatrue}{\@tud@res@swafalse}% + \if@tud@res@swa% + \appto\tud@res@a{fil##2}% + \tud@if@strequal{##2}{}{}{% + \tud@if@strequal{##2}{l}{}{% + \tud@if@strequal{##2}{ll}{}{\@tud@res@swafalse}% + }% + }% + \fi% + }% + \expandafter\tud@res@c\tud@res@a filfil\@nil% + \fi% +% \end{macrocode} +% Das Vorzeichen nicht vergessen! +% \begin{macrocode} + \edef\tud@res@c{% + \endgroup% + \if@tud@res@swa% + \unexpanded{\def#1}{\tud@res@b\tud@res@a}% + \else% + \unexpanded{\let#1\relax}% + \fi% + }% + \tud@res@c% +} +% \end{macrocode} +% Mit diesem Makro wird ganz am Ende des Interpretationsprozesses das Ergebnis +% mit dem angegbenen Argument verglichen und eine Warnung erzeugt, falls die +% Formatierung des Argumentes es notwendig machte, dieses zu interpretieren. +% \begin{macrocode} +\newcommand*\tud@validate@gluekey[3]{% + \begingroup% +% \end{macrocode} +% Unterschiede bei Leerzeichen sollen keine Warnung erzeugen. +% \begin{macrocode} + \protected@edef\tud@res@a{#2}% + \protected@edef\tud@res@b{#3}% + \tud@remove@spaces@within\tud@res@a% + \tud@remove@spaces@within\tud@res@b% + \ifx\tud@res@a\tud@res@b% + \aftergroup\@gobble% + \else% + \aftergroup\@firstofone% + \fi% + \endgroup{% + \PackageWarning{tudscrbase}{% + The length `#3'\MessageBreak% + seems to be wrong formatted. Assuming, you meant\MessageBreak% + `#1=#2'% + }% + }% +} +% \end{macrocode} +% \end{macro}^^A \tud@validate@gluekey +% \end{macro}^^A \tud@normalize@@gluekey +% \end{macro}^^A \tud@normalize@gluekey +% \end{macro}^^A \TUD@set@gluekey +% \begin{macro}{\TUD@set@dimkey} +% \changes{v2.05}{2016/06/15}{neu}^^A +% \changes{v2.06}{2018/08/01}{forcierte Kleinschreibung Schlüsselwerte}^^A +% Zur Angabe von Dimensionen wird auf \cs{TUD@set@gluekey} zurückgegriffen +% und anschließend geprüft, ob das Argument für \cs{dimen} genutzt werden kann. +% \begin{macrocode} +\newcommand*\TUD@set@dimkey[4][pt]{% + \begingroup% + \TUD@set@gluekey[{#1}]{#2}{\tud@res@a}{#4}% + \ifx\FamilyKeyState\FamilyKeyStateProcessed% +% \end{macrocode} +% Das Ergebnis der Wertzuweisung an \cs{TUD@set@gluekey} wurde im Makro +% \cs{tud@res@a} gespeichert. Handelt es sich beim Argument um ein +% \cs{skip}"~Register oder eine \cs{glueexpr}, kann nicht sichergestellt +% werden, dass diesem später doch noch Kleister hinzugefügt wird, weshalb diese +% nicht akzeptiert werden. +% \begin{macrocode} + \@tud@res@swafalse% + \Ifisskip{\tud@res@a}{% + \protected@edef\tud@res@a{\dimexpr\tud@res@a\relax}% + \def\tud@res@b{a \string\skip\space register}% + \@tud@res@swatrue% + }{% + \Ifisglueexpr{\tud@res@a}{% + \protected@edef\tud@res@a{\dimexpr\tud@res@a\relax}% + \def\tud@res@b{a glue expression}% + \@tud@res@swatrue% + }{% +% \end{macrocode} +% Ebenso wird direkt angegebener Kleister entfernt. Nicht über das Konstrukt +% mit \cs{@tempdima} und \cs{glueexpr} wundern. Ohne das Paket \pkg{calc} ist +% die Zuweisung von Kleister als String an ein \cs{dimen}-Register nicht ohne +% weiteres möglich. Die Verwendung \cs{glueexpr} dient quasi als Umschlag. +% \begin{macrocode} + \Ifisglue{\tud@res@a}{% + \Ifisdimension{\tud@res@a}{}{% + \setlength\@tempdima{\dimexpr\glueexpr\tud@res@a\relax\relax}% + \tud@strlength\tud@res@a{\@tempdima}% + \def\tud@res@b{something containing glue}% + \@tud@res@swatrue% + }% + }{}% + }% + }% +% \end{macrocode} +% Sollte einer der zuvor beschriebenen Fälle aufgetreten sein, wird eine +% Warnung ausgegeben. +% \begin{macrocode} + \if@tud@res@swa% + \PackageWarning{tudscrbase}{% + Using option `#2' with\MessageBreak% + \tud@res@b\space(#4)\MessageBreak% + is not recommended. You should consider to use\MessageBreak% + an expression for a dimen instead. Setting\MessageBreak% + `#2=\tud@res@a'% + }% + \fi% + \protected@edef\tud@res@a{% + \endgroup% + \unexpanded{\FamilySetUseLengthMacro{TUD}{#2}{#3}}{\tud@res@a}% + }% + \else% + \def\tud@res@a{\endgroup\FamilyKeyStateUnknownValue}% + \fi% + \tud@res@a% +} +% \end{macrocode} +% \end{macro}^^A \TUD@set@dimkey +% \begin{macro}{\TUD@unknown@keyval} % Dieser Befehl wird lediglich pro forma definiert. An diesen kann eine Liste % möglicher Wertzuweisungen übergeben werden, welche durch \KOMAScript{} % derzeit jedoch nicht abgearbeitet und ausgegeben wird. @@ -770,10 +1367,9 @@ \newcommand*\TUD@unknown@keyval{\FamilyUnknownKeyValue{TUD}} % \end{macrocode} % \end{macro}^^A \TUD@unknown@keyval -% \end{macro}^^A \TUD@set@dimenkey -% \end{macro}^^A \TUD@set@numkey -% \end{macro}^^A \TUD@bool@numkey -% \end{macro}^^A \TUD@set@ifkey +% +% \subsubsection{Voreinstellungen für abhängige Optionen} +% % \begin{macro}{\tud@locked@newnum} % \begin{macro}{\tud@locked@num@preset} % \begin{macro}{\tud@locked@num@set} @@ -781,10 +1377,11 @@ % definieren, für das mit \cs{tud@locked@num@preset}\marg{Name}\marg{Definition} % eine Voreinstellung definiert werden kann, solange der Wert nicht mit % \cs{tud@locked@num@set}\marg{Name}\marg{Definition} explizit überschrieben -% wurde. +% wurde. Damit ist es möglich, Voreinstellungen abhängig von anderen Optionen +% zu realisieren. % \begin{macrocode} \newcommand*\tud@locked@newnum[2]{% - \expandafter\newcommand\expandafter*\csname#1\endcsname{#2}% + \expandafter\newcommand\expandafter*\csname #1\endcsname{#2}% \newbool{#1@locked}% \tud@num@set{#1}{#2}% } @@ -799,8 +1396,15 @@ \booltrue{#1@locked}% } \newcommand*\tud@num@set[2]{% - \ifcsdef{#1}{% - \ifnumber{#2}{% + \ifcsundef{#1}{% + \PackageError{tudscrbase}{% + `\@backslashchar#1' was never defined% + }{% + You tried using the numerical expression `\@backslashchar#1'\MessageBreak% + but you didn't define it with `\string\tud@locked@newnum'.% + }% + }{% + \Ifnumber{#2}{% \csdef{#1}{#2}% }{% \PackageError{tudscrbase}{% @@ -810,13 +1414,6 @@ to value `#2', which isn't numerical.% }% }% - }{% - \PackageError{tudscrbase}{% - `\@backslashchar#1' was never defined% - }{% - You tried using the numerical expression `\@backslashchar#1'\MessageBreak% - but you didn't define it with `\string\tud@locked@newnum'.% - }% }% } % \end{macrocode} @@ -850,7 +1447,7 @@ \booltrue{#1@locked}% } \newcommand*\tud@bool@set[2]{% - \ifstrbool{#2}{\booltrue{#1}}{\boolfalse{#1}}{% + \tud@if@strbool{#2}{\booltrue{#1}}{\boolfalse{#1}}{% \PackageError{tudscrbase}{% `#2' is not a valid boolean expression% }{% @@ -872,7 +1469,7 @@ % \begin{macro}{\TUD@parameter@@family} % \begin{macro}{\TUD@parameter@checkfamily} % Mit \cs{TUD@parameter@family}\marg{Familienname}\marg{Definitionen} können -% Schlüssel"=Wert"=Parameter für die optionalen Argumente von Befehle definiert +% für die optionalen Argumente von Befehlen Schlüssel-Wert-Parameter definiert % werden. Das erste Argument definiert den Familiennamen für den jeweiligen % Befehl, welcher eindeutig gewählt werden sollte. Dieser wird im Hilfsmakro % \cs{TUD@parameter@@family} gesichert. Dies soll im Zusammenspiel mit dem @@ -882,10 +1479,10 @@ % Parameter für den Benutzer bewerkstelligen~-- ohne die Angabe der Familie % nur innerhalb des zweiten Argumentes von \cs{TUD@parameter@family} verwendet % werden können. -% \ToDo{% -% Eine Katastrophe, dringend überarbeiten; generelle Lösung mit \cs{toks@}?% -% KOMA-Option \val{@else@} verwenden? -% }[v2.07]% +% \ToDo{ +% Eine Katastrophe, dringend überarbeiten; generelle Lösung mit \cs{toks@}? +% KOMA-Option \val{@else@} verwenden? +% }[v2.07] % \begin{macrocode} \newcommand*\TUD@parameter@@family{} \newcommand*\TUD@parameter@family[2]{% @@ -897,7 +1494,7 @@ % Dieser Befehl prüft, ob eine Familie für den Paramter definiert wurde. % \begin{macrocode} \newcommand*\TUD@parameter@checkfamily[2]{% - \ifxblank{#1}{% + \tud@if@strblank{#1}{% \PackageError{tudscrbase}{% No family for \@backslashchar#2 defined% }{% @@ -953,7 +1550,7 @@ \IfArgIsEmpty{#2}{}{% % \end{macrocode} % Hierfür wird die angegebene Parameterliste sukzessive abgearbeitet. Elemente, -% welche in Schlüssel"=Wert"=Syntax angegeben wurden, bleiben unverändert\dots +% welche in Schlüssel-Wert-Syntax angegeben wurden, bleiben unverändert\dots % \begin{macrocode} \let\@tempb\@empty% \def\@tempa##1{% @@ -1016,15 +1613,15 @@ % Das erste obligatorische Argument von \cs{TUD@parameter@handler@macro} wird % für die Verarbeitung unbekannter Schlüssel-Wert-Paare genutzt, das zweite für % einfache optionale Argumente. -% \ToDo{% -% Eine Katastrophe, dringend überarbeiten; generelle Lösung mit \cs{toks@}?% -% KOMA-Option \val{@else@} verwenden? -% }[v2.07]% +% \ToDo{ +% Eine Katastrophe, dringend überarbeiten; generelle Lösung mit \cs{toks@}? +% KOMA-Option \val{@else@} verwenden? +% }[v2.07] % \begin{macrocode} \newcommand*\TUD@parameter@handler@macro[3][\TUD@parameter@@family]{% \TUD@parameter@checkfamily{#1}{TUD@parameter@handler@macro}% \expandafter\kv@set@family@handler\expandafter{#1}{% - \ifstr{\kv@key}{\TUD@parameter@nokey}{#3}{#2}% + \tud@if@strequal{\kv@key}{\TUD@parameter@nokey}{#3}{#2}% }% } % \end{macrocode} @@ -1041,7 +1638,7 @@ \protected@edef\@tempa{% \noexpand\TUD@parameter@set{#1}{#2=\noexpand\kv@value}% }% - \def\@tempb{\TUD@parameter@handler@macro[#1]{\kv@handled@false}}% + \def\@tempb{\TUD@parameter@handler@macro[{#1}]{\kv@handled@false}}% \expandafter\@tempb\expandafter{\@tempa}% } % \end{macrocode} @@ -1056,22 +1653,24 @@ % \begin{macrocode} \newcommand*\TUD@parameter@handler@default[2][\TUD@parameter@@family]{% \TUD@parameter@checkfamily{#1}{TUD@parameter@handler@default}% - \ifxblank{#2}{% + \tud@if@strblank{#2}{% \def\@tempa{\let\tud@reserved\relax}% }{% \def\@tempa{\def\tud@reserved{#2=\kv@value}}% }% \appto\@tempa{% - \ifstr{\kv@value}{twocolumn}{\def\kv@value{2}}{}% - \ifnumber{\kv@value}{\def\tud@reserved{columns=\kv@value}}{}% + \tud@if@strequal{\kv@value}{twocolumn}{\def\kv@value{2}}{}% + \Ifnumber{\kv@value}{\def\tud@reserved{columns=\kv@value}}{}% \iflanguageloaded{\kv@value}{\def\tud@reserved{language=\kv@value}}{}% \ifx\tud@reserved\relax% - \PackageError{tudscrbase}{% - Unknown default value `\kv@value'% - }{% - If `\kv@value' is a language, you haven't loaded it. \MessageBreak% - Otherwise, there's no handler for the given value. \MessageBreak% - You should specify a certian key (<key>=\kv@value).% + \tud@if@strblank{\kv@value}{}{% + \PackageError{tudscrbase}{% + Unknown default value `\kv@value'% + }{% + If `\kv@value' is a language, you haven't loaded it. \MessageBreak% + Otherwise, there's no handler for the given value. \MessageBreak% + You should specify a certian key (<key>=\kv@value).% + }% }% \fi% }% @@ -1080,24 +1679,25 @@ \noexpand\TUD@parameter@set{#1}{\noexpand\tud@reserved}% \noexpand\fi% }% - \def\@tempb{\TUD@parameter@handler@macro[#1]{\kv@handled@false}}% + \def\@tempb{\TUD@parameter@handler@macro[{#1}]{\kv@handled@false}}% \expandafter\@tempb\expandafter{\@tempa}% } % \end{macrocode} % \end{macro}^^A \TUD@parameter@handler@default -% \begin{macro}{\TUD@parameter@error} -% Das Makro \cs{TUD@parameter@wrn}\marg{Parameter}\marg{Werteliste} gibt für +% \begin{macro}{\TUD@parameter@err} +% Das Makro \cs{TUD@parameter@err}\marg{Parameter}\marg{Werteliste} gibt für % den Fall einer ungültigen Wertzuweisung an einen bestimmten \meta{Parameter} -% eine Warnung mit einem entsprechenden Hinweis auf gültige Werte innerhalb von +% einen Fehler mit einem entsprechenden Hinweis auf gültige Werte innerhalb von % \meta{Werteliste} aus. % \begin{macrocode} -\newcommand*\TUD@parameter@error[2]{% +\newcommand*\TUD@parameter@err[2]{% \PackageError{tudscrbase}{Unsupported value for parameter `#1'}{% `#1' can only be used with values:\MessageBreak#2% + \MessageBreak Please choose a valid one.% }% } % \end{macrocode} -% \end{macro}^^A \TUD@parameter@error +% \end{macro}^^A \TUD@parameter@err % % \subsection{Ausführung von paketspezifischem Quellcode} % @@ -1105,11 +1705,16 @@ % Ladezustand eines Paketes auszuführen. % \begin{macro}{\TUD@UnwindPackage} % \changes{v2.05}{2015/10/28}{neu}^^A +% \changes{v2.06o}{2022/08/02}{Sternversion}^^A % Dieser Befehl dient zur Ausführung von Quelltext, falls ein Paket bis zum % Ende der Dokumentpräambel nicht geladen wurde. Im ersten obligatorischen -% Argument wird das Paket angegeben, im zweiten der Quellcode. +% Argument wird das Paket angegeben, im zweiten der Quellcode. Die Sternversion +% führt den Quellcode auch nach dem Laden des Paketes aus. % \begin{macrocode} -\newcommand*\TUD@UnwindPackage[2]{\AtEndPreamble{\@ifpackageloaded{#1}{}{#2}}} +\NewDocumentCommand\TUD@UnwindPackage{s m m}{% + \IfBooleanT{#1}{\AfterPackage*{#2}{#3}}% + \AtEndPreamble{\@ifpackageloaded{#2}{}{#3}}% +} \@onlypreamble\TUD@UnwindPackage % \end{macrocode} % \end{macro}^^A \TUD@UnwindPackage @@ -1125,12 +1730,13 @@ % zu laden. Ist das Paket gar nicht installiert, wird durch den Aufruf von % \cs{RequirePackage} ein Fehler erzeugt respektive MiKTeX zur automatischen % Nachinstallation animiert. +% \ToDo{.aux schreiben, wenn existent und so ggf. nur einmalig ausführen}[v2.07] % \begin{macrocode} \newcommand*\TUD@CheckPackage[2]{% \tud@if@packagelater@exists{#1}{#2}{}{% \PackageWarningNoLine{tudscrbase}{% The version `#2' of package `#1'\MessageBreak% - is urgently required. An erroneous output\MessageBreak + is urgently required. An erroneous output\MessageBreak% may occur. Please update your distribution% }% \IfFileExists{#1.sty}{}{\RequirePackage{#1}[#2]}% @@ -1139,35 +1745,38 @@ \@onlypreamble\TUD@CheckPackage % \end{macrocode} % Hiermit wird geprüft, ob ein installiertes Paket in einer bestimmten Version -% installiert ist, ohne dieses zu laden. Hierfür wird die Datei zeilenweise -% gelesen, bis der Eintrag \cs{ProvidesPackage\marg{Paketname}\oarg{Version}} -% gefunden wird. +% vorhanden ist, ohne dieses zu laden. Hierfür wird die Datei zeilenweise +% gelesen, bis der Eintrag \cs{ProvidesPackage}\marg{Paketname}\oarg{Version} +% gefunden wird. +% \ToDo{kann \cs{@ifl@t@r} ersetzt werden?}[v2.07] +% \ToDo{Name in \cs{IfPackageExistsAtLeastTF} ändern}[v2.07] % \begin{macrocode} \newcommand*\tud@if@packagelater@exists[2]{% \begingroup% \let\tud@res@a\@empty% \def\tud@res@b[##1]{\def\tud@res@a{##1}}% \def\ProvidesPackage##1{% - \@ifnextchar[%] - {\tud@res@b}{\tud@res@b[]}% + \kernel@ifnextchar[%] + {\tud@res@b}% + {\tud@res@b[]}% }% \IfFileExists{#1.sty}{% - \openin\tud@res@read=#1.sty% + \openin\@inputcheck=#1.sty% \@tud@res@swatrue% \loop% - \read\tud@res@read to\tud@res@c% + \read\@inputcheck to\tud@res@c% \@expandtwoargs\in@{\string\ProvidesPackage}% {\expandafter\detokenize\expandafter{\tud@res@c}}% \ifin@% \@tud@res@swafalse% \tud@res@c% \fi% - \ifeof\tud@res@read\@tud@res@swafalse\fi% + \ifeof\@inputcheck\@tud@res@swafalse\fi% \if@tud@res@swa% \repeat% - \closein\tud@res@read% + \closein\@inputcheck% }{}% - \edef\tud@res@a{\endgroup\noexpand\@ifl@t@r{\tud@res@a}{#2}} + \edef\tud@res@a{\endgroup\noexpand\@ifl@t@r{\tud@res@a}{#2}}% \tud@res@a% } \@onlypreamble\tud@if@packagelater@exists @@ -1176,18 +1785,19 @@ % \end{macro}^^A \TUD@CheckPackage % \begin{macro}{\TUD@RecommendPackage} % \changes{v2.06}{2018/07/12}{neu}^^A +% \begin{macro}{\TUD@Recommend@Package} % Bestimmte Pakete sind für die Funktionalität von \TUDScript empfohlen, aber % nicht zwingend erforderlich. Sind diese nicht vorhanden, wird eine Warnung % ausgegeben. % \begin{macrocode} \newcommand*\TUD@RecommendPackage[1]{% \kernel@ifnextchar[%] - {\TUD@@RecommendPackage#1}% - {\TUD@@RecommendPackage#1[]}% + {\TUD@Recommend@Package#1}% + {\TUD@Recommend@Package#1[]}% } \@onlypreamble\TUD@RecommendPackage -\newcommand*\TUD@@RecommendPackage{} -\def\TUD@@RecommendPackage#1[#2]{% +\newcommand*\TUD@Recommend@Package{} +\def\TUD@Recommend@Package#1[#2]{% \IfFileExists{#1.sty}{% \RequirePackage{#1}[#2]% }{% @@ -1197,8 +1807,9 @@ }% }% } -\@onlypreamble\TUD@@RecommendPackage +\@onlypreamble\TUD@Recommend@Package % \end{macrocode} +% \end{macro}^^A \TUD@Recommend@Package % \end{macro}^^A \TUD@RecommendPackage % \begin{macro}{\TUD@AfterPackage@set} % \changes{v2.04}{2015/03/09}{neu}^^A @@ -1214,17 +1825,16 @@ \AfterAtEndOfPackage*{#1}{\booltrue{@tud@#1@loaded}}% } \newcommand*\TUD@AfterPackage@do[2]{% - \ifcsdef{if@tud@#1@loaded}{% - \if@atdocument% - \ifbool{@tud@#1@loaded}{#2}{}% - \else% - \AfterAtEndOfPackage*{#1}{#2}% - \fi% - }{% + \ifcsundef{if@tud@#1@loaded}{% \PackageError{tudscrbase}{\string\TUD@AfterPackage@set{#1} missing}{% You have to set \string\TUD@AfterPackage@set{#1} before\MessageBreak% - the usage of \string\TUD@AfterPackage@do{#1}{<code>} is\MessageBreak% - possible.% + using \string\TUD@AfterPackage@do{#1}{<code>}.% + }% + }{% + \tud@if@preamble{% + \AfterAtEndOfPackage*{#1}{#2}% + }{% + \ifbool{@tud@#1@loaded}{#2}{}% }% }% } @@ -1251,13 +1861,14 @@ \ifundef{\KOMAClassName}{% \renewcommand*\TUD@KOMAoptions[1]{% \PackageWarning{tudscrbase}{% - You should load package `scrextend' right after the\MessageBreak% - documentclass. Option \string\TUD@KOMAoptions{`#1'} is gobbled% + You should load package `scrextend' right after\MessageBreak% + the documentclass. The following option is gobbled:\MessageBreak% + \string\KOMAoptions{`#1'}% }% }% - \AfterPackage*{scrextend}{\let\TUD@KOMAoptions\KOMAoptions}% + \AfterPackage*{scrextend}{\def\TUD@KOMAoptions{\KOMAoptions}}% }{% - \let\TUD@KOMAoptions\KOMAoptions% + \def\TUD@KOMAoptions{\KOMAoptions}% } %</package&base> % \end{macrocode} @@ -1284,7 +1895,6 @@ % \fi % % \section{Zusätzliches für die \TUDScript-Klassen} -% % \subsection{Erweiterung von \KOMAScript-Schriftelementen} % % \begin{macro}{\tud@komafont@set} @@ -1294,7 +1904,7 @@ % Es wird die Möglichkeit geschaffen, bestimmten Schriftelementen weitere % Eigenschaften mitzugeben. Damit dies optionsabhängig geschehen kann und % \cs{addtokomafont} nur einmalig verwendete werden muss, wird im Zweifelsfall -% einem Schriftelement ein Hilfsmakro \cs{tud@komafont@\meta{Element}} +% einem Schriftelement ein Hilfsmakro |\tud@komafont@|\meta{Element} % zugewiesen, welches intern angepasst werden kann. Mit \cs{tud@komafont@set} % werden dem angegebenen Element die gewünschten Schriftattribute zugeteilt. % \begin{macrocode} @@ -1345,7 +1955,7 @@ % \env{tudpage} wird das Paket \pkg{environ} für die Umgebungsdefinition % benötigt. % \begin{macrocode} -\RequirePackage{environ}[2013/04/01] +\RequirePackage{environ} % \end{macrocode} % % Innerhalb dieser Umgebungen soll es außerdem möglich sein, ein mehrspaltiges @@ -1397,13 +2007,15 @@ which now will be loaded automatically% }% }{}% - \RequirePackage{graphicx}[1999/02/16]% + \RequirePackage{graphicx} }% % \end{macrocode} % Mit dem Paket \pkg{tudscrcolor} werden die Befehle für die Auswahl der Farben % des \CDs definiert, welches wiederum \pkg{xcolor} lädt. % \begin{macrocode} - \RequirePackage{tudscrcolor}[\TUD@Version]% + \RequirePackage{tudscrcolor}[% +%!TUD@Version + ]% } % \end{macrocode} % @@ -1411,60 +2023,6 @@ %</class&body> % \fi % -% \Finale +% \PrintBackMatter % \endinput - -% -% \begin{macro}{\TUD@noworlater} -% \changes{v2.05}{2015/07/03}{neu implementiert}^^A -% \begin{macro}{\TUD@noworlater@simple} -% \changes{v2.05}{2015/07/03}{neu}^^A -% Hiermit kann die Abarbeitung der Optionen an das Ende der verwendeten -% Klasse bzw. des Paketes verzögert werden. Aufgrund der Besonderheiten der -% Befehle \cs{AtEndOfClass} und \cs{AtEndOfPackage} können diese nicht -% innerhalb von \pkg{tudscrbase} sondern erst außerhalb nach dem Laden -% definiert werden. Damit keine Probleme dabei auftreten, falls das Paket -% geladen wird ohne daran anschließend die notwendigen Redefinitionen -% durchzuführen, werden die beiden Varianten des Befehls \cs{TUD@noworlater} -% im Paket definiert. -% -% Im ersten Argument von \cs{TUD@noworlater} wird einer der wertzuweisenden -% Befehle für Optionen (\cs{TUD@set@\dots}) erwartet. Dieser wird immer -% ausgeführt, um ungültige Wertzuweisungen einer Option, welche als globale -% Klassenoption angegeben wurde, über die \LaTeX-Standardroutine als Warnung -% auszugeben. Bei der eigentlichen~-- sprich verzögerten~-- Ausführung der -% Option wird die Wertzuweisung abermals ausgeführt, gefolgt von der im -% zweiten Argument definierten Abarbeitung dieser. -% \begin{macrocode} -%<*package&base> -\newcommand*\TUD@noworlater[2]{} -\newcommand*\TUD@noworlater@simple[2]{% - \PackageWarning{tudscrbase}{% - The content of \string\TUD@noworlater will be executed immediately% - }% - #1#2% -} -\let\TUD@noworlater\TUD@noworlater@simple -%</package&base> -% \end{macrocode} -% Nach dem Laden des Paketes wird geprüft, ob die ursprüngliche Definition -% des Befehls aus dem Paket noch besteht. Ist dies der Fall, wird der Befehl -% zur Verzögerung an das Ende der Klasse bzw. des Paketes umdefiniert. -% \begin{macrocode} -%<*load> -\ifx\TUD@noworlater\TUD@noworlater@simple -%<*class> - \renewcommand*\TUD@noworlater[2]{#1\AtEndOfClass{#1#2}}% - \AtEndOfClass{\renewcommand*\TUD@noworlater[2]{#1#2}}% -%</class> -%<*package> - \renewcommand*\TUD@noworlater[2]{#1\AtEndOfPackage{#1#2}}% - \AtEndOfPackage{\renewcommand*\TUD@noworlater[2]{#1#2}}% -%</package> -\fi -%</load> -% \end{macrocode} -% \end{macro}^^A \TUD@noworlater@simple -% \end{macro}^^A \TUD@noworlater -% |